{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-colab"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/pathwaycom/pathway/blob/main/examples/notebooks/tutorials/gaussian-filtering-python.ipynb\" target=\"_parent\"><img src=\"https://pathway.com/assets/colab-badge.svg\" alt=\"Run In Colab\" class=\"inline\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "notebook-instructions",
      "source": [
        "# Installing Pathway with Python 3.10+\n",
        "\n",
        "In the cell below, we install Pathway into a Python 3.10+ Linux runtime.\n",
        "\n",
        "> **If you are running in Google Colab, please run the colab notebook (Ctrl+F9)**, disregarding the 'not authored by Google' warning.\n",
        "> \n",
        "> **The installation and loading time is less than 1 minute**.\n"
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "id": "pip-installation-pathway",
      "source": [
        "%%capture --no-display\n",
        "!pip install --prefer-binary pathway"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "id": "logging",
      "source": [
        "import logging\n",
        "\n",
        "logging.basicConfig(level=logging.CRITICAL)"
      ],
      "execution_count": null,
      "outputs": [],
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "id": "4",
      "metadata": {},
      "source": [
        "# Gaussian Filtering in Real-time: Signal processing with out-of-order data streams\n",
        "\n",
        "In this tutorial, you will learn how to perform signal processing on out-of-order signal data. Specifically, you will apply a Gaussian filter on a signal data stream with irregular sampling.\n",
        "This is an important skill to master because most real-world signal processing scenarios do not follow the regular and precise timing assumptions on which many standard signal processing systems are built.\n",
        "Read our blog on [the challenges of real-time signal processing](/blog/signal-processing) for more context.\n",
        "\n",
        "The tutorial will walk you through the following 3 steps:\n",
        "1. Preprocess the noisy data using interval joins;\n",
        "2. Apply a Gaussian filter to smoothen the signal;\n",
        "3. Dive deeper into how Pathway handles out-of-order data points.\n",
        "\n",
        "## Signal Processing with Pathway\n",
        "\n",
        "Standard DSP systems do not support the addition of late data points because they assume a perfectly regular sampling. This allows these systems to wait until all signals to arrive before starting the processing computation.\n",
        "But in real-world and real-time settings, these assumptions are rarely guaranteed. Data points may arrive late or, worse, not at all, in which case the computation would never start.\n",
        "Pathway allows you to manipulate streaming data as if it were static, i.e., as if all the data is already gathered.\n",
        "**You don't have to worry about the late or out-of-order data: Pathway will handle it by updating its results whenever late or out-of-order points are added to the system.**\n",
        "\n",
        "However, you still have to deal with data misalignment.\n",
        "Therefore, **you must consider the signal as a time series**, and data points should be seen as a list of (time, value) pairs rather than an array of regularly sampled values.\n",
        "While the time variable makes signal processing more complex, Pathway offers several functions to make signal processing on realtime data streams as simple as it can be.\n",
        "\n",
        "## Gaussian Filtering in Python: Preprocess the data\n",
        "\n",
        "Because of the out-of-order data points, the use of IIR ([Infinite Impulse Response](https://en.wikipedia.org/w/index.php?title=Infinite_impulse_response&oldid=1079405495)) filters, which depend on the sequential order of data, is impractical as their outputs cannot be efficiently recomputed when late points arrive.\n",
        "Instead, Pathway offers ways to easily implement FIR ([Finite Impulse Response](https://en.wikipedia.org/w/index.php?title=Finite_impulse_response&oldid=1172063361)) filters, where each data point influences the filter's response for a limited duration.\n",
        "Consequently, you should primarily employ kernel smoothing techniques to process signals in a manner that accommodates unordered or non-sequential data points, ensuring accurate and efficient analysis.\n",
        "\n",
        "Furthermore, without sample numbers, you cannot rely on a prev/next order among your data points: not only some points may be missing, but there may also be an important temporal gap between two consecutive points.\n",
        "You need to connect your point to other points close in time.\n",
        "To do so, Pathway provides [interval joins](/developers/user-guide/temporal-data/interval-join).\n",
        "\n",
        "Interval joins merge records by comparing the timestamp from each record of two tables and evaluating whether the difference falls within a specified time window or `interval`.\n",
        "\n",
        "![Illustration of interval join](https://pathway.com/assets/content/tutorials/fleet_eta_interval_join/illustrative_interval_join.png)\n",
        "\n",
        "Interval joins are a great tool to gather all the close points together:\n",
        "\n",
        "```python\n",
        "results = table_a.interval_join_left(\n",
        "    table_b,\n",
        "    pw.left.timestamp,\n",
        "    pw.right.timestamp,\n",
        "    pw.temporal.interval(-50, 50),\n",
        "    pw.left.timestamp != pw.right.timestamp\n",
        ").select(\n",
        "    pw.left.timestamp,\n",
        "    neighbor_timestamp=pw.right.timestamp,\n",
        ")\n",
        "```\n",
        "\n",
        "However, they create an entry for each point in the interval:\n",
        "\n",
        "```\n",
        "timestamp | neighbor_timestamp\n",
        "------------------------------\n",
        "...\n",
        "100       | 77\n",
        "100       | 97\n",
        "100       | 132\n",
        "...\n",
        "------------------------------\n",
        "```\n",
        "\n",
        "To gather all the entries corresponding to the same interval, we could use a `groupby` followed by a `reduce`.\n",
        "\n",
        "```python\n",
        "results = results.groupby(results.timestamp).reduce(\n",
        "    results.timestamp,\n",
        "    neighbors=pw.reducers.tuple(pw.this.neighbors_timestamps),\n",
        ")\n",
        "```\n",
        "\n",
        "```\n",
        "timestamp | neighbors\n",
        "------------------------------\n",
        "...\n",
        "100       | (77, 97, 132)\n",
        "...\n",
        "------------------------------\n",
        "```\n",
        "\n",
        "In Pathway, you can obtain the same results directly using `windowby` with `intervals_over`.\n",
        "Both the `interval_join` and `intervals_over` approach arrive at the same result. The `intervals_over` is preferred in this case because of its compact syntax. We will use the `intervals_over` in this tutorial.\n",
        "\n",
        "```python\n",
        "results = table_a.windowby(\n",
        "    table_a.timestamp,\n",
        "    window=pw.temporal.intervals_over(\n",
        "        at=table_b.timestamp, lower_bound=-50.0, upper_bound=50.0\n",
        "    ),\n",
        ").reduce(\n",
        "    pw.this._pw_window_location,\n",
        "    neighbors=pw.reducers.tuple(pw.this.timestamp),\n",
        ")\n",
        "```\n",
        "\n",
        "## 2. Apply Gaussian Filtering with Pathway\n",
        "\n",
        "Now that you know how to aggregate the data, let's do some signal processing!\n",
        "\n",
        "Let's start with a simple Gaussian filter in Pathway.\n",
        "A Gaussian filter is a linear filter used to reduce the noise of a signal.\n",
        "The filter works by smoothing the signal using a convolution, applying a Gaussian function to a local segment of the signal.\n",
        "I will not delve into details: if you are interested you can check out the [Wikipedia article](https://en.wikipedia.org/w/index.php?title=Gaussian_filter&oldid=1161463896).\n",
        "\n",
        "To apply a Gaussian filter, you first need to aggregate the local segments: each point is associated with its surrounding counterparts.\n",
        "This aggregation is done using an *interval join* in data streaming processing (note: an interval join is usually done on two different data streams, but it is possible to do a self-interval join. See our [tutorial](/developers/user-guide/temporal-data/interval-join) for more info about interval joins).\n",
        "You can easily perform a regular interval join using Pathway with `interval_join`, but in this case you will need to aggregate the points to perform a convolution, so we will use the `windowby` and `intervals_over` syntax we saw earlier.\n",
        "\n",
        "Before entering the details, let's generate some data to play with.\n",
        "\n",
        "### The data\n",
        "\n",
        "For this example, you will work on static data.\n",
        "However, in a real use case, your data source might be a data stream.\n",
        "Fortunately, you won't need to change the code, as Pathway works transparently with static and streaming data: you will only need to update your input connector to connect to your live data.\n",
        "\n",
        "The raw data needs to be noisy to see the impact of a Gaussian filter.\n",
        "Let's generate noisy data by first generating \"perfect data\": data ranging from 0 to 10000 for the timestamps, and the values are generated by adding to an increasing trend some periodic patterns.\n",
        "Then, some normally distributed noise is added to both."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5",
      "metadata": {},
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "6",
      "metadata": {
        "lines_to_end_of_cell_marker": 2
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "\n",
        "np.random.seed(10)\n",
        "nb_points = 1000\n",
        "\n",
        "# Generate x values\n",
        "x = np.linspace(0, 10000, nb_points)\n",
        "x_noise = np.random.normal(0, 2, nb_points)\n",
        "x = x + x_noise\n",
        "x = np.sort(x)\n",
        "\n",
        "# Generate y values with a globally increasing trend and periodic patterns\n",
        "trend = 0.01 * x  # Globally increasing trend\n",
        "periodic_pattern = 50 * np.sin(2 * np.pi * x / 1000)  # Periodic pattern\n",
        "periodic_pattern2 = 70 * np.sin(2 * np.pi * (x % 10) / 1000 + np.pi)  # Periodic pattern\n",
        "noise = (0.001 * 10000) * np.random.normal(0, 1, nb_points)\n",
        "\n",
        "# Combine trend and periodic pattern to create y values\n",
        "y = trend + periodic_pattern + periodic_pattern2 + noise"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7",
      "metadata": {
        "lines_to_next_cell": 2
      },
      "source": [
        "Let's plot the signal:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "8",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "def set_params_plot():\n",
        "    plt.xlabel(\"time\")\n",
        "    plt.ylabel(\"value\")\n",
        "    plt.xticks([], [])\n",
        "    plt.yticks([], [])\n",
        "    plt.title(\"\")\n",
        "\n",
        "\n",
        "# Plot the data points\n",
        "plt.subplot(2, 1, 1)\n",
        "set_params_plot()\n",
        "plt.plot(x, y)\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9",
      "metadata": {},
      "source": [
        "Now you can convert this data to Pandas and load it to Pathway"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "10",
      "metadata": {},
      "outputs": [],
      "source": [
        "import pandas as pd"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "11",
      "metadata": {},
      "outputs": [],
      "source": [
        "import pathway as pw\n",
        "\n",
        "# To use advanced features with Pathway Scale, get your free license key from\n",
        "# https://pathway.com/features and paste it below.\n",
        "# To use Pathway Community, comment out the line below.\n",
        "pw.set_license_key(\"demo-license-key-with-telemetry\")\n",
        "\n",
        "\n",
        "\n",
        "def load_to_pathway(x, y):\n",
        "    time_series_pd = pd.DataFrame({\"x\": x, \"y\": y})\n",
        "    return pw.debug.table_from_pandas(time_series_pd)\n",
        "\n",
        "\n",
        "time_series = load_to_pathway(x, y)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "12",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "mappingproxy({'x': float, 'y': float})"
            ]
          },
          "execution_count": null,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "time_series.typehints()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "13",
      "metadata": {},
      "source": [
        "And that's it! Now, let's see how to build and apply a Gaussian filter in Pathway.\n",
        "\n",
        "### Computing aggregations with `windowby`\n",
        "\n",
        "You want to obtain an aggregation of the closest points for each point.\n",
        "With streaming data, you do not have any assumption on the distribution of surrounding points.\n",
        "You can ask for a fixed number of previous/next points, but you'd take the risk to obtain points with very different timestamps.\n",
        "So the solution is to ask for the data points in an interval around your point.\n",
        "\n",
        "To do so, you can use `windowby`, that takes three arguments:\n",
        " 1. The column used for windowing: the timestamp in the column `x`.\n",
        " 2. The window: in your case you will use an `intervals_over` window.\n",
        " 3. The optional sharding: not relevant here.\n",
        "\n",
        "For `intervals_over`, you need to set the parameter `at`, defining the column of times for which windows are to be created and the `lower_bound` and the `upper_bound` of the interval.\n",
        "Let's try with an interval of length 100:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "14",
      "metadata": {},
      "outputs": [],
      "source": [
        "points_within_50 = time_series.windowby(\n",
        "    time_series.x,\n",
        "    window=pw.temporal.intervals_over(\n",
        "        at=time_series.x, lower_bound=-50.0, upper_bound=50.0, is_outer=False\n",
        "    ),\n",
        ").reduce(\n",
        "    pw.this._pw_window_location,\n",
        "    xs=pw.reducers.ndarray(pw.this.x),\n",
        "    ys=pw.reducers.ndarray(pw.this.y),\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "15",
      "metadata": {},
      "source": [
        "### Gaussian Filtering in Python as a UDF\n",
        "\n",
        "Now that you have the intervals, you need the Gaussian filter.\n",
        "In Pathway, you can easily define a User-Defined Function (UDF) with the `@pw.udf` annotation.\n",
        "To perform a Gaussian filter, you need the data points gathered by the `windowby` and the associated time (called `window_location`).\n",
        "The times and the values are kept in separate columns, so we takes two different arrays as input:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "16",
      "metadata": {},
      "outputs": [],
      "source": [
        "import scipy.stats\n",
        "\n",
        "\n",
        "# UDF for Gaussian filter\n",
        "@pw.udf\n",
        "def gaussian_filter(\n",
        "    times: np.ndarray,\n",
        "    values: np.ndarray,\n",
        "    window_location,\n",
        ") -> float:\n",
        "    stdev = (max(times) - min(times)) / 2\n",
        "    gaussian_distribution = scipy.stats.norm(window_location, stdev)\n",
        "\n",
        "    coefficients = gaussian_distribution.pdf(times)\n",
        "    normalized_coefficients = coefficients / sum(coefficients)\n",
        "    return np.dot(values, normalized_coefficients)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "17",
      "metadata": {},
      "source": [
        "With the UDF, you can directly apply the filter to each interval, without using `pw.apply`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "18",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Applying the Gaussian filter\n",
        "time_series_filtered = points_within_50.select(\n",
        "    x=pw.this._pw_window_location,\n",
        "    y=gaussian_filter(pw.this.xs, pw.this.ys, pw.this._pw_window_location),\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "19",
      "metadata": {},
      "source": [
        "### Displaying the output\n",
        "\n",
        "Let's plot the results.\n",
        "Let's first output the data in Pandas and then plot the timeseries.\n",
        "In practice you'd use a [output connector](/developers/user-guide/connect/pathway-connectors) to output the results to Kafka or Postgres."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "20",
      "metadata": {},
      "outputs": [],
      "source": [
        "time_series_filtered_pd = pw.debug.table_to_pandas(time_series_filtered)\n",
        "time_series_filtered_pd = time_series_filtered_pd.sort_values(by=[\"x\"])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "21",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.subplot(2, 1, 1)\n",
        "plt.plot(x, y)\n",
        "plt.plot(time_series_filtered_pd.x, time_series_filtered_pd.y)\n",
        "set_params_plot()\n",
        "\n",
        "plt.subplot(2, 1, 2)\n",
        "plt.plot(time_series_filtered_pd.x, time_series_filtered_pd.y, color=\"#ff7f0e\")\n",
        "set_params_plot()\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "22",
      "metadata": {},
      "source": [
        "See how smooth the new plot is compared to the noisy raw data!"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "23",
      "metadata": {},
      "source": [
        "## Gaussian Filtering in Python: Handling Late and Out-of-Order data points\n",
        "\n",
        "Now that your pipeline is ready, Pathway will manage late and out-of-order points by updating its results whenever new (or late, in this case) data points come into the system.\n",
        "\n",
        "But what does it mean exactly? What happens when late points arrive?\n",
        "\n",
        "As a reminder, a standard DSP system will retain the data until all the data is ready to apply the Gaussian filter.\n",
        "**In a streaming system, you cannot afford to wait for data points for an undetermined time: some data points may be lost and never arrive!\n",
        "Pathway computes an output with whatever data is available then and revises the result whenever new data points arrive.**\n",
        "\n",
        "Let's see the impact on late data points in our example by delaying the arrival of several points.\n",
        "\n",
        "For clarity, let's focus on a small sample of the data:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "24",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhcAAADPCAYAAABGK/MjAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAXdlJREFUeJzt3Xd4VNXWwOHfzCST3kkljZIEQmihg1IEBFFEAanKB/ZyRRG7VyxYsAFGr6LeK2ADC6ioiHQQ6QFCT0JCek9IrzNzvj9OMklIIWWSmYT9Pk+eMDNnztmMmLOy99prKSRJkhAEQRAEQTAQpbEHIAiCIAhC5yKCC0EQBEEQDEoEF4IgCIIgGJQILgRBEARBMCgRXAiCIAiCYFAiuBAEQRAEwaBEcCEIgiAIgkGZGeOiOp2OlJQU7OzsUCgUxhiCIAiCIAjNJEkSBQUFeHl5oVQ2PD9hlOAiJSUFHx8fY1xaEARBEIRWSkxMxNvbu8HXjRJc2NnZAfLg7O3tjTEEQRAEQRCaKT8/Hx8fH/19vCFGCS6qlkLs7e1FcCEIgiAIHcy1UhpEQqcgCIIgCAYlggtBEARBMDGrdkQRtiu63tfCdkWzakdUO4+oeURwIQiCIAgmRqVUsLKeACNsVzQrd0ShUpr2Tkuj5Fw0hVarpaKiwtjDEATMzc1RqVTGHoYgCNeRxeMDAFhZOUOxeHyAPrB4amKg/nVTZXLBhSRJpKWlkZuba+yhCIKeo6MjHh4eoi6LIAjt5q7B3hyPy2HljihW7YhCgg4RWIAJBhdVgYWbmxvW1tbih7lgVJIkUVxcTEZGBgCenp5GHpEgCJ1ZbnE5f55N49dTyRy5nIMkyc9LgJlS0SECCzCx4EKr1eoDCxcXF2MPRxAAsLKyAiAjIwM3NzexRCIIgkGVlGvZdTGdX06msC8qgwqtpH+tq6MlybmlAGh0EmG7ojtEgGFSwUVVjoW1tbWRRyIItVX9m6yoqBDBhSAIrabR6jhwKYstp1L461waReVa/Wu9POyYNqAr2YVl/PfAZcYGurI3KpPuXWxq5WCYMpMKLqqIpRDB1Ih/k4IgtJYkSZxIyGXLqWR+P51KdlG5/rWujlZMG+DFtAFdCfKwI2xXNP89cJmnJgYyqqcLe6MyyS/VsGRCQIcIMEwyuBAEQRCEziIqvYBfTyXz66kUkq6U6J93tlFzWz9Ppg3wItTXqdYvMVqdpE/eLCnXolIqyCosY9YQHxQKBVqdVN+lTIYILgSjGDt2LAMGDGD16tXGHoogCILBJeeW8FtECr+cTOZiWoH+eWu1ikl9PJg2wItRPbtgrqq/3NSSiYH6P1upVQS42XIxrYCIxDyTnrGoIoILA1m4cCHr168HwMzMDGdnZ/r168fcuXNZuHBho61pr7Zu3TqefPJJsR1XEAShA8kpKmfrmVS2nErhaFyO/nlzlYIxgW5MG+DFhN7uWKmbn7fV39uRi2kFnE7KZXKIhyGH3SY6XXCxqrJyWX2RXdiuaLQ6qVZEaEiTJ09m7dq1aLVa0tPT2bZtG0888QQ//fQTW7Zswcys033cgiAInVZT7icPjenOjvPpbDmVwr6oTDQ1liuGdXNm2oCu3BLigZONulVj6efjwPfHEzmdlNeq87SXTlf+25glUy0sLPDw8KBr166Ehoby4osv8uuvv/Lnn3+ybt06/XErV66kb9++2NjY4OPjw6OPPkphYSEAe/fuZdGiReTl5aFQKFAoFLz66qsAfPPNNwwePBg7Ozs8PDyYN2+evv5CQz755BMCAgKwtLTE3d2dmTNn6l/btm0bN9xwA46Ojri4uHDbbbcRExOjfz0uLg6FQsEPP/zAjTfeiJWVFUOGDCEqKopjx44xePBgbG1tmTx5MpmZmfr3LVy4kDvuuIPXXnsNNzc37O3teeihhygvL6ch5eXlPPvss3Tt2hUbGxuGDRvG3r17m/HpC0Lb6Og9HoSWa+h+smpHFCt3RPHXuTQGLd/JExtPsetiBhqdRB8ve16c0ouDz9/E9w+NYN4w31YHFiDPXACcTspFkkw73wI6wMyFJEmUVGivfWCl+2/sRoVWx8odUVRodTwytgef7o3ho92XePymntx/YzeKyzVNOpeVuarVuwRuuukm+vfvz+bNm7n//vsBUCqVhIWF4e/vz+XLl3n00Ud59tln+eSTTxg5ciSrV69m2bJlREZGAmBrawvIN+Dly5cTFBRERkYGS5YsYeHChWzdurXeax8/fpzFixfz9ddfM3LkSHJycvj777/1rxcVFfHUU0/Rt29fioqKWLZsGXfeeSenTp2qtYzzyiuvsHr1anx9fbn33nuZO3cu9vb2fPjhh1hbWzNr1iyWLVvGp59+qn/Prl27sLS0ZM+ePcTFxbFo0SK6dOnCm2++We9YFy1aRFxcHBs3bsTLy4uff/6ZyZMnc+bMGQICTH99Uei8qm4wUDs7v2YpZqFzqlmCW5IkRvbswvLfz+tnD6pyKXydrSt3enjR082uTcYS5GGH2kxJfqmGuOxiunWxaZPrGIrJBxclFVqCl/3Vovd+tPsSH+2+1ODjazn/+iSs1a3/iHr16sXp06f1j5988kn9n7t168by5ct55JFH+OSTT1Cr1Tg4OKBQKPDwqL2udu+99+r/3L17d8LCwhg6dCiFhYX6AKSmhIQEbGxsuO2227Czs8PPz4+BAwfqX58xY0at4//3v//h5ubG+fPnCQkJ0T//9NNPM2nSJACeeOIJ5s6dy65duxg1ahQA9913X62ZGQC1Ws2XX36JtbU1ffr04fXXX+eZZ55h+fLldfJPYmJi2LBhA0lJSXh5eemvuW3bNtauXctbb73V4GcrCG2to/d4EFpn8fgAdJLEqp3RrNpZPYPRxVbNbf3kgGKAj2Obb1c3VykJ9rTnVGIup5NyRXAhyLMvNf/h7dmzh7feeovz58+Tn5+PRqOhtLSUoqIibGwa/gdz8uRJXn31VU6dOkVOTg46nQ6Qg4jg4OA6x0+cOBE/Pz+6d+/O5MmTmTx5Mnfeeae+IFRMTAwvv/wyhw8fJisrq9b5agYX/fr10//Z3d0dgL59+9Z67urlmf79+9cqhjZixAgKCwtJTEzEz8+v1rEnTpxAkiQCA2v/BlhWViYqtQomoWaAsXpnFDqp4/R4EFqvtEKn/7NSAesWDWVkDxfMGtjp0Vb6eTtUBhd5TBvQtV2v3VwmH1xYmas4//qkZr+vainEXKWgQivx+E09eWRsj2Zf2xAuXLhAt27dAIiPj2fKlCk8/PDDLF++HGdnZw4cOMB9993XaBfYoqIibr75Zm6++Wa++eYbXF1dSUhIYNKkSQ3mMtjZ2XHixAn27t3L9u3bWbZsGa+++irHjh3D0dGRqVOn4uPjwxdffIGXlxc6nY6QkJA65zM3N9f/uSpIuvq5qsDkWuqL7nU6HSqVivDw8DrVL+ubkREEY3hsXE9W7pADi47U40FonT9Op7Jmn5yLplLK9SVOJeYyOtC13cfSz9sRiOd0Um67X7u5TD64UCgUzV6aCNsVzUe7L+l/s6iawjRXKdv9B8Lu3bs5c+YMS5YsAeQ8CI1GwwcffKBfHvjhhx9qvUetVqPV1s4zuXjxIllZWaxYsQIfHx/9ua7FzMyMCRMmMGHCBF555RUcHR3ZvXs3Y8aM4cKFC3z22WfceOONABw4cKDVf98qERERlJSU6PtyHD58GFtbW7y9vescO3DgQLRaLRkZGfqxCIKpWf77ef2fO1KPB6HlItMKePL7kwAM9nPip0dG6u8n0P4VMvt7OwBwNjkfjVbX7jMnzWHywUVz1bcWWt+aaVsoKysjLS2t1lbUt99+m9tuu40FCxYA0KNHDzQaDR999BFTp07ln3/+Yc2aNbXO4+/vT2FhIbt27dIvL/j6+qJWq/noo494+OGHOXv2LMuXL290PL///juxsbGMHj0aJycntm7dik6nIygoCCcnJ1xcXPj888/x9PQkISGB559/3mCfRXl5Offddx///ve/iY+P55VXXuFf//pXvfU+AgMDmT9/PgsWLOCDDz5g4MCBZGVlsXv3bvr27cuUKVMMNi7BdBhz23hzhe2KZt3BuFrPdYQSzELL5ZVUMPuzQ1RoJXydrdj44HCg/e4n9enuaouNWkVRuZZLmYX08rBvt2s3l+mGPS1Us2RqTYvHB/DUxMA2LZm6bds2PD098ff3Z/LkyezZs4ewsDB+/fVX/XT/gAEDWLlyJe+88w4hISF8++23vP3227XOM3LkSB5++GFmz56Nq6sr7777Lq6urqxbt44ff/yR4OBgVqxYwfvvv9/oeBwdHdm8eTM33XQTvXv3Zs2aNWzYsIE+ffqgVCrZuHEj4eHhhISEsGTJEt577z2DfRbjx48nICCA0aNHM2vWLKZOnarfUluftWvXsmDBApYuXUpQUBC33347R44c0c/SCJ2PMbeNN0fVeIZ1c671/GB/p3rHL3R8Op3EkxtPkltSgZ2lGb88dkOtWYL2uJ/UR6VUENJVnr04nWja9S4UkhE2zObn5+Pg4EBeXh729tWRV2lpKZcvX6Zbt25YWlq297AEA1m4cCG5ubn88ssvxh6KwYh/m23j6plGU9yFUTXDciY5jx3n0xnZw4WDMdk426i5e7gvChQmM8MiGMbK7ZGE7b6EhZmSTY+M1N/QTcFbWy/w+f5Y7h7uyxt39L32Gwysofv31TrdsoggCB1HzSnmqmlmUwosoLrHw43v7gbg0bE9ic0sIi2/lJ5udtze38uYwxMMbPu5NMIqSxa8Pb2vSQUWAH2rZi5MvFJnp1sWEQShY5k2oPrmrFSYZg5DYZmGxBy5m2UfL3tmD5GX6747Em/MYQkGdimjkKd+iABg4Uh/pofWTUA3tqpKnRdS8ynTNL3AZHsTwYVgcOvWretUSyJC21ry/Sn9n3USJllOO7KyEqO7vQVONmrmDPVBqYDDsTlcyig08ugEQygoreChr49TWKZhaDdnXrq1t7GHVC8fZyucrM2p0EpcTC249huMRAQXgiAYzft/RXIiIRcAdWXC3Ie7ok0uSfJiWj6APjvf08GKm3rJBeU2HE0w2rgEw9DpJJb+EEFMZhEe9pb8Z15og63QjU2hUNC3Rp8RU2Wan54gCJ1e2K5oPt4jr233cLXh3hvkQnP+LtYmtwuj6jfEXp7VfSPmD/MF4KfwJEqb0f9IMD2f7L3E9vPpqFVK1twzCFc7C2MPqVFV9S4iTDjvQgQXgiAYhUarw9FarvS6cKQ/cyrzGOJzirn/hm7tvs2vMVUzF71r1BUYHehKV0cr8koq2Hom1VhDE1ppT2QGH1QuxS2/ow8DfByNO6Am6Fc5c3FGBBeCIAi1DfB1JLdYriMwPdQb/y42jOjugiSBjYWZyWzvlCRJ3/0yyKN65kKlVDB3aFVip1ga6Yjisop4YsNJJAnmDfNl9hBfYw+pSfpVzlxEZxQ0uct3exPBhSAIRrH2nzgA5gzxwcZC3hU/p/Jm/ePxRJOZuUjJK6WgVIOZUkEP19q9bmYN9sFMqeB4/BV90qfQMRSVaXjo63DySzWE+jryytS6zR9Nlbu9Je72FugkuRS4KRLBhSAI7S46vYC/o7NQKmDBCH/985P6eOBgZU5KXin7ozONN8AaLqbKP7x7utmiNqv9I9PN3pKJwXJip9iW2nFIksSzm04TmV6Aq50Fn949CAszwzSqbC/9TDypUwQX1zGFQtEmW0bHjh3Lk08+2aL3rlu3DkdHR4OOpyn27t2LQqEgNze33a99PVpb2adjYrA7Ps7W+uctzVXcOVBuJb3RRHZhVC2J9KqxJFLTvMrEzs0nk012ilqo7fP9sfxxOhUzpYJP54fibt/xqu6aelKnCC4MJCMjg4ceeghfX18sLCzw8PBg0qRJHDp0yNhD49VXX2XAgAHGHkaTzJ49m6go06tzIBhOXnEFm08kAbBoVLc6r88dKt+sd13IIKOgtF3HVp/qfIv6Sx2P6tEFPxdrCko1/B4hEjtN3YHoLN7ZdhGAV6YGM9jf+RrvME11Zi72vA373q3/4H3vyq+3o84XXBjpA54xYwYRERGsX7+eqKgotmzZwtixY8nJyWmT63VWVlZWuLm5GXsYQhvaeCyB0godvT3t6zQDAzlpcqCvIxqdxKbwZCOMsLaqZZGa21BrUioV+oDoWxOZbRHql5hTzL82nEAnwV2DvLl7uJ+xh9Swa9zLhsZ9BkB8djF5xRWgVMGeN+u+Z9+78vPK9l326XzBhRE+4NzcXA4cOMA777zDuHHj8PPzY+jQobzwwgvceuut+uMUCgWfffYZt912G9bW1vTu3ZtDhw5x6dIlxo4di42NDSNGjCAmJqbW+T/99FN69OiBWq0mKCiIr7/+utbrCQkJTJs2DVtbW+zt7Zk1axbp6emAvMzw2muvERERgUKhQKFQsG7dOv17s7KyuPPOO7G2tiYgIIAtW7bUOvf58+eZMmUKtra2uLu7c88995CVlaV/vaioiAULFmBra4unpycffPDBNT+viIgIxo0bh52dHfb29gwaNIjjx4/rx3v1ssgbb7yBm5sbdnZ23H///Tz//PO1ZmIWLlzIHXfcwfvvv4+npycuLi489thjVFRU6I/55ptvGDx4MHZ2dnh4eDBv3jwyMjKuOVbBsDRaHV8dknMTFo3yR6Gov/Np1bbU748lYITeinqlFVpis4qA2ttQrzZzkDfmKgURibmcTTbNaerrXUm5loe+Die3uIJ+3g4svyOkwX9/JuEa9zJLCzW+lUuKp5NzYcyzMO6l2u+puu+Ne0l+vT2H365XawlJgvKipn+NeAxGPyN/oLvfkJ/b/Yb8ePQz8utNPVcTf6jZ2tpia2vLL7/8QllZWaPHLl++nAULFnDq1Cl69erFvHnzeOihh3jhhRf0N9h//etf+uN//vlnnnjiCZYuXcrZs2d56KGHWLRoEXv27Kn8eCTuuOMOcnJy2LdvHzt27CAmJobZs2cD8jLD0qVL6dOnD6mpqaSmpupfA3jttdeYNWsWp0+fZsqUKcyfP18/25KamsqYMWMYMGAAx48fZ9u2baSnpzNr1iz9+5955hn27NnDzz//zPbt29m7dy/h4eGNfgbz58/H29ubY8eOER4ezvPPP4+5uXm9x3777be8+eabvPPOO4SHh+Pr68unn35a57g9e/YQExPDnj17WL9+PevWrasVRJWXl7N8+XIiIiL45ZdfuHz5MgsXLmx0nILh7TifTnJuCc426kYbft3WzwsbtYq47GIOxxpv9u9SRiFanYSjtTnu9g0XVupia8HkEE8AvhOzF7WsaqQgWtiu6HYp9y5JEi/+fIbzqfm42KhZc/cgLM1NPIGzvmBh7wr58fBHIGAidzldYoryMJqja+HAKqgoBq+B8jGvOhotsICO0BW1ohjeamHXwf3vyV8NPb6WF1NAbXPNw8zMzFi3bh0PPPAAa9asITQ0lDFjxjBnzhz69etX69hFixbpb87PPfccI0aM4OWXX2bSpEkAPPHEEyxatEh//Pvvv8/ChQt59NFHAXjqqac4fPgw77//PuPGjWPnzp2cPn2ay5cv4+Mj/7b39ddf06dPH44dO8aQIUOwtbXFzMwMDw+POmNfuHAhc+fOBeCtt97io48+4ujRo0yePJlPP/2U0NBQ3nrrLf3xX375JT4+PkRFReHl5cX//vc/vvrqKyZOnAjA+vXr8fZuvNlPQkICzzzzDL169QIgIKDhRlUfffQR9913n/4zWbZsGdu3b6ewsHY/BycnJz7++GNUKhW9evXi1ltvZdeuXTzwwAMA3Hvvvfpju3fvTlhYGEOHDqWwsBBb29rbC4W2U7X9dN5Q30Z/uNtYmHH7AC82HE3k+2MJjOjh0k4jrK1qe2mQu901f8udN9SX3yJS+PVkMi9O6Y2then/eG0PKqVC3/G2ZlO6sF3RrNwRxVPtUM9k3cE4fj6ZjEqp4ON5oXg5WrX5NVtMkqAgDTLOgZkFuIfIQcKeN6uPOfwpHP6UxwHUQHTlV+0TgUptlMACOsLMRQcxY8YMUlJS2LJlC5MmTWLv3r2EhobW+u0ZqBVsuLvLW9j69u1b67nS0lLy8+V13gsXLjBq1Kha5xg1ahQXLlzQv+7j46MPLACCg4NxdHTUH9OYmuOxsbHBzs5Ov1wQHh7Onj179DMztra2+oAgJiaGmJgYysvLGTFihP4czs7OBAUFNXrNp556ivvvv58JEyawYsWKOstANUVGRjJ06NBaz139GKBPnz6oVNU3K09Pz1rLHidPnmTatGn4+flhZ2fH2LFjATnQEdrH2eQ8jsblYKZUcM+Ia691z6ksaLT1bBq5xeVtPbx66Stzeja8JFJleHdnurvaUFSu5ddTxs8VMRWLxwfw1MRAVu6I4rlNp/k7OrNWYNHWXXAPx2bzxh/yz8IXp/Q2WqBar/JiSA6HE1/Bn8/Butvg3e6wshd8MwN2LIP0s3XfZ24Ndl4UOwZyVBfE34rB0H8uDHsE/G+Uj1Gagba84byNNmb6obW5tTyD0FwHVsmzFCq1/AGPfgZuWNL8azeDpaUlEydOZOLEiSxbtoz777+fV155pdb0e83p/6rfhOp7TqfT1XmuiiRJ+udq/rmhYxpz9XKEQqHQX1un0zF16lTeeeedOu/z9PQkOrplvR9effVV5s2bxx9//MGff/7JK6+8wsaNG7nzzjvrPb6+v39z/h5FRUXcfPPN3HzzzXzzzTe4urqSkJDApEmTKC83zk3relQ1azGlr2eTtv7183agl4cdF9MK+OVkMgvr2VnS1q61DbUmhULBvKG+vPHHBb47ksC8ob6mvabfjhaPDyA9v5RvjyTw/bFEAJZMCGjzwCIlt4THvj2BVidxxwAv7h3l36bXa5BOB1cuQ8Z5SD8nBwzp5yEnFqhn+V2hBJee4BYMJVfg8j5QmoOuAsY8B+NeBEAq0zDn1b/QlcPR8eNxOxkGcX9XL4VU5VxAu89gmH5woVA0aWmiln3vyoHF1R9wO08RBQcHt7qORO/evTlw4AALFizQP3fw4EF69+6tv0ZCQgKJiYn62Yvz58+Tl5enP0atVqPVNr+xUmhoKJs2bcLf3x8zs7r/VHr27Im5uTmHDx/G11f+LfPKlStERUUxZsyYRs8dGBhIYGAgS5YsYe7cuaxdu7be4CIoKIijR49yzz336J+ryk1pqosXL5KVlcWKFSv0n1FzzyG0TmZBGb9FyL8kLGriD3iFQt6F8cqWc2w8lsj/jWw4AbStXNA3LLv2zAXIiZ3v/hXJuZR8IpLyOkSfivag0eo4lZhb67nicm2TfwlqidIKLY98E052UTnBnva8Pb1f86+15205sbK++8a+d0GnhXEv1H6+OEcOIDLOVwcRGRegoqj+a9i4gnsfcOsjf3fvA65BYG5VNyFTvzHBDMY8i42FGT3dbIlKL6Tgr7dwO/dh7RyLqu9GCDBMP7horvqyY9v4A87Ozuauu+7i3nvvpV+/ftjZ2XH8+HHeffddpk2b1qpzP/PMM8yaNYvQ0FDGjx/Pb7/9xubNm9m5cycAEyZMoF+/fsyfP5/Vq1ej0Wh49NFHGTNmDIMHDwbA39+fy5cvc+rUKby9vbGzs8PC4tpd/x577DG++OIL5s6dyzPPPEOXLl24dOkSGzdu5IsvvsDW1pb77ruPZ555BhcXF9zd3XnppZdQKhtebSspKeGZZ55h5syZdOvWjaSkJI4dO8aMGTPqPf7xxx/ngQceYPDgwYwcOZLvv/+e06dP07179yZ/hr6+vqjVaj766CMefvhhzp49y/Lly5v8fqH1NhxNoFyrY4CPIwN9nZr8vjsGdOWtrRe4mFbQ7jfrrMIysgrLUCgg0L1peTmO1mpu6+vJ5pPJfHckXgQXlb74+zLnUuQlJpVCgVaS+Gx/LIVlGpZPC0GpNGyAIUkSy349S0RSHo7W5nx2zyCs1C1I4KzasQG17xtV95kh98PpHyqDiHNyIFHQwEy7ygLcesk5FG7B1YGEbQNb75t4L+vb1ZGo9EIy8oroUV/yZtVjXft27u18wYVOW392bBt+wLa2tgwbNoxVq1YRExNDRUUFPj4+PPDAA7z44outOvcdd9zBhx9+yHvvvcfixYvp1q0ba9eu1ecMVFXZfPzxxxk9ejRKpZLJkyfz0Ucf6c8xY8YMNm/ezLhx48jNzWXt2rVN2inh5eXFP//8w3PPPcekSZMoKyvDz8+PyZMn6wOI9957j8LCQm6//Xbs7OxYunQpeXkNb8VTqVRkZ2ezYMEC0tPT6dKlC9OnT+e1116r9/j58+cTGxvL008/TWlpKbNmzWLhwoUcPXq0yZ+hq6sr69at48UXXyQsLIzQ0FDef/99br/99iafQ2i5co2Orw9Xbz9tDgdrc6b09eTnk8lsPJrQrjfrqmROP2drrNVN/1E5b5gvm08m81tEKi/dGoyDVf07oa4Xl7OKeH97JAA3B7vz+YLBPLD+GDsuZPDtkQRKyrW8O7MfZirDpQB+eySBH44noVTAR3MH1qoC2yxjnpXvGXvehKwoORg4/aOcbKlQwrH/yl9Xc/SVgwj3PpWBRAg4dwdVM265TbyX9fdxYNOJJNYoZzNiTN18tFrvaUcKyQibyPPz83FwcCAvLw97++rpxtLSUi5fvky3bt2wtOx45ViF9jFx4kQ8PDzq1PtoS+LfZsv9cjKZJ78/hbu9BQeeuwnzZt5EDsdmM+fzw1irVRx9aUK77cL479+xvPHHBSb38WDNPYOa/D5Jkpi0ej9R6YW8dnsf/m+kf9sN0sTpdBKj391DUm4Jfs7W7H1mrH5p4tFvwtl6Ng2AyX08+HDuAIP09wiPz2HO54ep0Eo8f0svHh7To2lvLMqG7GjIiq7+nhUt50roGijrbuEA7jVmIdz6gFtvsGzaMpohnErM5Y7//IOTtTknXp7Y5kuHDd2/r9b5Zi6ETqW4uJg1a9YwadIkVCoVGzZsYOfOnezYscPYQxOaQJIk1v5zGYC7h/k1O7AAGNbNmW5dbLicVcTvESnMGdo+bbH1yZwNVOZsiEKhYP4wP17Zco7vjiSwYITfdZvYufFYIkm5JZgpFXxz/7Ban8Mndw9i8YaT/H46hW3n0njwq3DW3N3A8kUTcx/S80t5+JsTVGglbu3ryUOjr1o+1ZTLwYI+gLgkz0hkR8uJkw0xt4aKEkAChQrmbpBnJBy85bxAI+rtaYe5SsGV4gqSrpS0fJbGwERwIZg0hULB1q1beeONNygrKyMoKIhNmzYxYcIEYw9NaIITCblEJOWhNlPqG3w1l0KhYPYQH1b8eZGNxxLbLbiIbMZOkavdMbArb/95gcj0Ak4kXGGQX8fsX9EaaXmlvL1V3gL6/C296r3phc0dyF2DvXnwq3D2RWWycO1R/rdwSN3ZqWvlPox7iXKNjke/PUFmQSlDXTW8P7QQxYn1lYFEZRBxJR6kRpbGHXzkXRpdAqBLYPWfT34Le9+q3n2YGgGBk1r7ERmEhZmKXh72nEnOIyIpVwQXgtAUVlZW+uRVoeOpmrWY1t8LF9trJxE3ZEaoN+//FcmpxFwupuXTq5FS3Iag0eqISq8KLpp/LQcrc6b28+LH8CS+PZxw3QUXkiTx8q9nKSjT0N/Hsd4GdVVuDHDlq/uGcu/aYxy5nMP8/x5h/aIhOFqrqw+qLyl/z1uw7x3oMx0USs79Zy7/zr5ED8tU7AuK4NsGLqi2rQ4aXAKgS085kHDuAep6bsz73pUDCxPY3tmQft4OnEnO40xSHrf1a2HRSQMTwYUgCG0iNa+EPyvX1Bu7uTSFq50FE3q7s+1cGhuPJvLq7X0MMcQGxWUXU6bRYWWu0vdvaK75w/34MTyJ38+ksmxqcO2bZSf359k0dpxPx0yp4J0ZfVFdYzfIEH9nvntgOAu+PEJEYi5zPj/M1/cNw9WuMiAtzACPfuB/Q91qlec2w7nNDIQaZSEV4OhTOftQGUC4BMgBhZ1n05cyjLD7sCX6eTvw7RGIqOqQagJEcCEIQpv4+lA8Wp3EsG7OBHu1fqZhzlAftp1L4+eTyTx/S6827Q2hL/vtYdfibZL9vR0I9rTnfGo+P4Uncf+NTd8+3ZHlFpez7NdzADw6tge9LvwHIq+dL9HX24HvHxrBg1/sxjnjEL989AN3++ZglREB+Un1X8zCniK7buzIsCda60mfvqFMGTda3plhboAS30bYfdgSVe3Xzybno9NJBt/a2xImGVzUrE4pCKZA/JtsntIKLRsqG3i1dtaiyo0BrnR1tCI5t4S/zqUxbUBXg5y3PlVlv1uSb1FFoVAwf7gvL/18lu+OJnDfDd1ML7GzJUWiruHNPy6QVVhGTzdbHrupJ/xzjXyJ0AVyr4zkEwSmnGCv5pLcL6McuFR1sEKehTBTQ9oZuYiUTkPRoEeYED6M1PJSJga7s3TWIDDkjbWxv7sJzFhUCXCzxdJcSWGZhtisQnq6tfzfraGYVHChVqtRKpWkpKTg6uqKWq02vf8ZheuKJEmUl5eTmZmJUqlErb5+prZb49dTyVwprsDbyYqJwe4GOadKqeCuwd6s3hnNhqMJbRpc6CtztiK4AJg2oCtv/XGB2MwijlzOYXh3E+prAU1KlGyOA9FZ/Bweh52inA+m9MSiIAmCp0FBqny+K5fBeyiEr4PUU4BC7qtxFY29L38X+3CoxJcEy148vXA2PWO/rrVEod3zDjb73mJmxUz+cL2HlbP6m8Rv7MZgplIS4uXA8fgrRCTmieDiakqlkm7dupGamkpKSgv6iQhCG7G2tsbX17fR6qOCTN5+GgfA/43wv+Z6e3PMGuzDh7uiORybw+WsIrp1aWZrgCbSz1w0sex3Q2wtzLh9QFc2HE3g2yMJphdc1MwfSDsDfqMgahvE7gHf4VCUBVsWg6ZU3opZ63spaEoqv5ciaUoYXl7CJcvKWb6N9Vzv1Hfyl54Etu7gFQpdQ+XvXgMxs3GhT0EpK/57lMj0Anp//jJPqH6stUTxRuFt2FZEsdT8JwbYOGJnObYtPymT18/bkePxVzidlMuMQY13pm4PJhVcgDx74evri0ajaVE/DEEwNJVKhZmZmZhFa6JDsdlcTCvAylzFrCE+135DM3g5WjEm0JW9kZl8fyyR52/pZdDzAxSUyvUCoPUzFwDzh/my4WgC286mkl0Y3KpdMwaVGQUXf4eov+THF7bIX1USDstfTaSgnhuKmaX8ZW4lf78Sh75WxKz1cjBh71VvgqWbnSXfPzSc//vyKFKalg8qZpKZNZkVwM8nkyoD2OkA3KAW/2/293EA4HRywxWS25PJBRcgr1Wam5vX6XQpCILpq5q1mDGoa5uUvp4zxJe9kZn8FJ7E0psDW1SYqzFVW1A97C0NssMjpKsD/b0diEjK46fwJB5qasVIQ9Pp5PbeF3+Hi3/IhaNqUSDf+JUwaCGYWYG5ZY3vNYIEM8tar0VmaXho4zmKJTUfzBvGjb19wMyidtBQs4Gktlxu5tV7aqNDdrRW8839w7hvvYqjl3PgWCJp+aUcisnWH2N+0/MMa+Puqh1B365ycHE+JZ8Krc7g/180l0kGF4IgdEwJ2cXsvJAOwMKRbdMifXxvN7rYWpBVWMauCxlMDvEw6PmrO6Eabt163jBfIpLO8N3RBB64sXv75QZoyuDyfjmgiPwTCtOrX1OaQ/cx0OtWyLkMB8Oqb/x2nk1OWCzX6HjixwPESe5MG+DFjf3qudE31N0TrnkdO0tz1i8aykPfhLM/KpO9kZn6155sh7btHYW/iw12lmYUlGqITCsgpDLYMBaxgCwIgsGsPxSHJMHoQFd6ujWtk2hzmauUzKxcU/7+WILBz1+9U8Rwhbqm9vfCzsKM+OxiDtb4rbtZ9rwt35Trs+9d+XWA0jw48xP8uBDe7QHfzpQTKAvTQW0HITNg5pfwbCzcvUnOqzgYJt/4X86Uv+95s+FrXeXz/TFcTCvAydqcZbcFNzC2empFNOM6VmoVXywYxKQ+1cnB5ioFT04IbNIYrwdKpYJ+3pVLI0nGXxoRwYUgCAZRWKbhh2OJQPO7nzbX7Mpcjn1RmaTklhj03K0p+90Qa7UZd4bKu1u+PRLfspNU7ey4+mZcdfNOPQVf3ykHFJvug3M/Q3kB2HrA4HvlQOLZGDmwCJkhN9dq5Y3/UkYhYbvk/aKvTO1Tfz5JY7Uixr3U5FoRFmYqelcGfOYqBRVaibBdVy/tXN+q6l2cNoFiWmJZRBAEg9gUnkRBmYbuXWwYE+Daptfq1sWG4d2dORybw4/Hk3higmGmxiVJ4mIbLIuAvDTy1aF4dpxPJ6OgFDe7ZnbXrbmzQ5Kgzx3w57MQu1d+Pmpb9bFdAuXljl63yUmTDe1yakWRKJ1O4oXNpynX6hgb5Mq0AQ2UnTZQrYiwXdGs3hXNUxMDWTw+gLBd0azcEQUglkYq9a+cuYgwgZkLEVwIgtBqOp3E+oNxACwc5d8uOQVzhvhyODaHH44n8q+behpky2tybgkFZRrMVQq6dzHssk4vD3sG+TkRHn+FH48n8di4nk1/c1E2pJwEFOASKPe62PtW7WO8h8gBRdCt4NrE5YJW3Pi/PRLPsbgr2KhVvHln3zbdTVUVSFQFFlAdUIgAo1rVzEVUegGlFdo2rWJ7LSK4EASh1fZFZxKbVYSdpRkzQttnj/3kEA8ctpiTnFvCgUtZjAls/WxJ1axFD1db1GaGXzWeN9SX8PgrfHckgYfH9Kg/ICrJlZc4Uk5Wf+U2lFuigNtWQtAUsDNsYmtjUnJLWPHnRQCendyLro4GKLXdCK1OqhVYVKl6rNVJbXr9jsLTwZIutmqyCss5l5LPID8no41FBBeCILRa1fbT2YN9sLm6XXYbsTRXcefArqw7GMfGowkGCS4i0w2fb1HTrf08ef338yTnlrA/OpNx/laQerp2IJETU/+bXXqC10AouQKXdlbv7CjKatfAQpIk/v3LWYrKtYT6OnL3cL82v+aSiQ3PxIgZC9mqHVGolAr6eTuy+2IGp5Ny9cFF2K5otDqp0c/R0ERwIQhCq1zKKGR/VCYKBSwY4d+u1549xId1B+PYcT6drMIyurSyQNWFVMNU5qxXeTGW6WdZ4X2I4rijBP2UABWJQD2/dTv6yYFEV7liJZ79wdKhVVs6DWVLRAq7L2agVil5Z0Y/g1ZgFVpOpVSwckcUI7o7A9U7RmouKbUnEVwIgtAq6w5eBmBCb3d8XVrWnrylenva09/HkYjEXDZdq0BVE5p0XUwbCVw1c9GS5l6aMkg/ByknKmckTslFoyQttwCogIrKY+27ygFEzS9r5/qvZeT23zlF5bz223kAHhvXkwB34/ewEGRX56BEJOXWm6vSXkRwIQhCi+UVV7ApPBlo++2nDZk7xIeIxFy+P5bIg6O7N5xYeI0mXRWjX+ByVhEgBy1NfR9jnpf7ciSfqF7aSD8HugrqsHGDrqH8mNKFrTmejLjhJh6cMrJpf1ETaP+9/Pfz5BSVE+RuxyNjjVRpVGjQ4vEBFJdrWLMvltjMIqMFFiCCC0EQWuH74wmUVGjp5WHHCCM15bqtvxev/36e2Kwijl7OYVhD46jvt/waswGRPR9Cu/0AjtbmuNlZ1H6fJMnHacqg712w+w24+Js86/DPati3ou71rJz0jbj0X5V9NNSnktmz8RQXTpVw7yQdZk0p1Wzk9t97IzP4+WQyCgWsmNG3TRJehdZ7/pbefLY/FkmS64EYKydFBBeCILSIRqtj/UG5INSiUf5Ga+xma2HG7f292Hgske+PJTYcXIB8Ey65IgcKe98GSSfnN1zahdeJX9imzsdBoUOxWil3/tSUg7ZMDioA/n5f/qqSL8/aYGEPXgNqBxKOfvU25AJ5p4uzjZq0/FL2RGYarC19Wykq0/DSz2cBWDSyGwN9jbcLQWhc2K5oJAnUKiXlWh1hu6I71szFpUuXiImJYfTo0VhZWSFJkugaKQjXkZ0X0knOLcHJ2pxpA7oadSyzh/iw8Vgif5xJ5ZWpfXCwvqphWnYMnP8Fzv8KqRHyc1Jla/DceMiNxxlwVgJa4Jo1iBQw/NHqQMK5e8OFquphYabirkHefLY/lu+OxJt8cPHeX5Ek55bg7WTF05NEyW1TdXWOhTELjTU7uMjOzmb27Nns3r0bhUJBdHQ03bt35/7778fR0ZEPPvigLcYpCIKJqdp+Om+Yr1GL9QAM8HGkl4cdF9MK+DUiWd61khklBxPnf4H0szWOrur+qQJJC8F3QMgM3t8dx8mUYu4d04vxIT6gspA7e5pZyH8+sgYOrKzeAmrlCP3uavGY5w715bP9seyNyiQxpxgf5/ZNhm2q8PgrrD8UB8Bbd/bFWi0mvE2RqRUaa/ai2ZIlSzAzMyMhIQFr6+r/GWbPns22bdsaeacgCJ3FuZQ8jlzOwUyp4J7h/sYeDgqFgjmDvQlQJKHY9w7Sf4bDf4bAnjfkwEKhgh43ycWmkOTEyFdy5O/nf4HMi2zMDeYfXV9cgsdC10HgEQJdAsDRF06slwOLFjb3qo9/Fxtu6NkFSYLvK3uymJoyjZbnN51GkmBGqDejDVBLRGgbjRUae2piYLsXGmt2CLp9+3b++usvvL1rV+ELCAggPr6FDXkEQehQ1lXOWtzS1xMPh2b2yDAkSZJ3Zpz/lXvO/sxCi2goRf5SmkP3sXIPjqApcOy/jW7lnFsxk48V0wl0v6rsdxtuAZ03zJcDl7L4/ngiT0wIwLwpiZ3t6JM9MURnFOJio+bft/Y29nCERphaobFmBxdFRUW1ZiyqZGVlYWHRugI2giCYvuzCMn6NSAFg4Uj/9h+AJEHaaXnJ49wv+oqWKkCjMGevJoQc/ynMmveAvGOjSiNbOeOzi1CdSMDfxabutH8bbgGdGOxOF1sLMgvK2Hk+nVv6erb4XIYWlV7AJ3vljqev3t4HJxu1kUckdCTNDi5Gjx7NV199xfLlywF5OlKn0/Hee+8xbtw4gw9QEATT8t2RBMo1Ovp7OxDq69g+F5UkuX5EVVLmlbjq11QWEDARgqdxwnwI968/j028iluVdtjUPEcjWzl3uP4fqzUXuKW+st9tuAXUXKVk9hBv/rMnhu+OJphMcKHVSTz702kqtBITertxWz/TGJfQcTQ7uHjvvfcYO3Ysx48fp7y8nGeffZZz586Rk5PDP//80xZjFATBRJRrdHx9uGr7abfW7RC7ZuVLDQTcDOd+hvNbIK9G8y4zK31AQeAksJCDgiGShL9LHHHZxfxxOpVZQ3yaNJSLaXJPkaA26inSmDlDfPlkbwx/R2cRl1WEfxeba7+pja0/GMepxFxsLcxYfkeI2AkoNFuzF/iCg4M5ffo0Q4cOZeLEiRQVFTF9+nROnjxJjx6iYpsgdGZ/nk0lo6AMNzsLprT2t+yqypc1kyJ1OtjyuPz84U/hv+Ph0MdyYGFuDX3uhLvWwTOXYPbX0HemPrAAeSZ19hBfADYca6iTaF0X0yp7ini0QU+Ra/BxttY3XWvOmNtKYk4x72+PBOD5W3rh6dC2HU+FzqlFe4o8PDx47bXXDD0WQRBM3JeViZx3D/drfYXGmkmRWdFyfsSpb6G8UH6+LB/UthA4WZ6h6DkB1NferjljUFc+2B7JyYRcItMKrjkbodHqiEqXr9nb0zi9MuYN9WVvZCY/HU/iqYmBWJgZZ2uvJEm89MtZisu1DO3mzLyhvkYZh9DxNTu42L9/f6Ovjx49usWDEQTBdJ1IuEJEYi5qlZJ5w1p40ykrlItYpZyA5HD5C+DMD9XHqCzkHR7B06DHeDBv3m4UNztLxvd2469z6Ww8lsArU/s0enxcdjHlGh3WahU+TsapNXFTLzc87C1Jyy/lr3Pp3N7fq12uW9Wmu2o3wc8nk9kflYnaTEkfT3s+3BXdrm26hc6j2cHF2LFj6zxXcz1Oq2375jmCILS/qu2ntw/walprc60GMs5XBxHJJyDzQnVlTL2qnx8SKM3ghUS5cFUrzBnqy1/n0vn5ZDLPTe7VaJGvqiWRQHc7lEZqH26mUjJ7iA8f7ormuyPx7RZcVLXpBnlb7Ou/yx1Ph/g7sfZgXLu36RY6j2YHF1euXKn1uKKigpMnT/Lyyy/z5ptvGmxggiAYQQNJlml5pXQ79x+eNNMyYeTquu+TJHkHR1UQkRwuz1BoSuoea98VuobKhaq6DoLYvfD3B9WVL//5sNW7MEYHuOLlYElKXil/nUtrtDz5xVQ5mdNYSyJV5gz14aPd0RyOzeFSRiE93Wyv/aZWqlnB8Y8zqeQWV+Bqa8E/l7KN1k1T6ByaHVw4ODjUeW7ixIlYWFiwZMkSwsPDDTIwQRCMoIH24pd+WsYSsx/53vYeQro6QFFWjRmJyoCiJKfu+SwcoOvA6kDCKxTsaySC7ntXDiyq6khUFay66vrNpVIquGuwPBPw/bHExoMLIyZz1uTpYMVNvdzYeSGDDUcTePm24Ha57uLxAUSmFfDHmVQAMgvLRGAhtJrBisS7uroSGRlpqNMJQod19Tp2TWG7otHqpBavYx/639OgVDFi0Tt1X1v7HOi0jLjv/Xre2UT1VJ6s2PE6NyR+xl5tP0Y7ZsHqvpBbz64GlRo8+lYHEl0HgXOPhht6tWHlS4C7BnsTtjuagzHZxGcX4edS/xZPY25Dvdr8YX7svJDBphNJPDMpqF16toTH57DjQrr+sVqlFIGF0GrNDi5Onz5d67EkSaSmprJixQr69+9vsIEJQkdVcx275g/pmo2FWkypYkT8Gg6tpVaAcWjtc/Lzfg/X/z5JgopiOaGyvBDKCiq/N/DYc4B8g9/zFubIPQnGqk5DUo3//7sE1ggkQsE9pHm5Em1Y+RLA28ma0QGu7IvK5PtjiTw7uVedY/JLK0i6Ii/d9DKB4GJ0oCtdHa1Izi1h65lUpod6X/tNrRCXVcT9649TrpHzYIzdplvoPJodXAwYMACFQoEk1W6CMnz4cL788kuDDUwQOqqa69garY77buzOZ/ti+GRvDA+P6c6coT6k55eikyR0Euh0EpJE5WOp+nlJQqeTv1e9bjn+eXb9Vsz4+DVErLxIl55D0EVtZ0RhBJk2AYywTIT1U2sEDZXfywvrSaRsCvn/8zTJiRLXAXTrf2Pl8sZAsKy7RNosbVj5ssqcIT7si8rkx/AklkwMrNO7I6py1sLTwRJHa+OXt1YpFcwd6sP726P47khCmwYXV4rKWbTuGFeKKwB4/KaeLL05yKhtuoXOo9nBxeXLl2s9ViqVuLq6YmlpxOZFgmBK9rzNYjMV8aE3E7b7EmG7L+lfMj/wPt/9o2O1ZuY1TiLhSi49lSn0UFR/dVemMlCRBUD//L1wYq/+Ha5F0RAZfY3zKuTaERa2V323q/049RRc3o9OYYZS0vCDNJH/u/cTsDZvySdiNON7u9PFVk1mQRl7LmZwcx+PWq9fqAwuTGHWosqswT6s3hnN8fgrTarT0RKlFVoe/Po4l7OKAHhodHeW3hwEGLdNt9B5NDu48PPza4txCELnUZkUOcI+kU1M1j/9uGozS81/YqVmJmZKBUqFArVCg78inR6KZLorUuiuSKEbyfiRih3FDV4iF3vspQKUCgmtpOBj7Z0USpYUYVX53ZIylTUuTi54uLri6+lK964eBHq74WLXcMXFVTuiGJ70P0bE74dxL/Fw/E0ERX7KUvMfOPS9M4e97+tQdQ/UZkpmhHrz2f5YNh5LrBNcRFYmcwYZOZmzJjd7Syb0dmfbuTS+OxLPa9NCDHp+nU7imZ9OcyzuCmqVgrlDfXlhSu2Op1UBRXu36RY6jyYFF2FhYU0+4eLFi1s8GEHoFMY8S25xOTOPvEe8qpg1zOBJNvCY+RYIupWnXDx5KusryIqSt29KDeQWKJTg1A26BFR+BcpfLgFc+OFdRsSvoVwyQ63Q0NvLifTQJ7iYmk9yWgEXU/MpKtdCBvLXuSxAnvFws7Ogl6c9vT3s6O1pTy9PO7p3sUVtpqwMLOTcDe++/2Lntj1sl6Yz0NeRm+LXVA6sbjKpKZs9xIfP9seyNzKD1LySWuWsTWUb6tXmD/dl27k0Np9M5rlbetXt1NoK72+P5LeIFMyUCtYtGsrInl3qPU7MWAit0aR/satWrWrSyRQKhQguBAF4IP4m7tIcYan5Tyzlp+oXIv+oe7DarkbwUCOIcO5Wb4JkzeTNEYve4dDa57g5fg2HLphzT2WSp04nkXSlhAtp+VxIzediagEX0vKJzy4mo6CMjIJM9kdl6s9prlLQ082OJ1WlbLJfwNLI0fT77gQ6Cfycrbn38k1sCDJjhL+joT+qNtfd1ZZh3Zw5cjmHH48n6W+akiTpd4oYexvq1Ub16IKvszUJOcX8HtH0BmzXsuFoAp/slVvUr5jRr8HAQhBaq0nBxdV5FoIgNOzjbaeYmrSSWWa1S+XnW3hwqtgVe58+DBg4RD8LgZ0HNLHr5NWBBVAZYFBrF4lSqcDXxRpfF2sm1VgKKCrTEJleoA84LqbJ3wvKNFxIzechbtYfezopD4D4nGKemhjIiPG3tvajMZo5Q304cjmH748l8q9xPVEqFSRdKaGwTIO5SkF3V+N3Iq1JqZSXK97ZdpFvjyYYJLjYH5XJv385C8AT4wOYOahtd6II1zfDzbUJ15W2rOXQocXuY87xB+lillb9nNIcdBXYj7yPU5o70eokBgxp4Wej09YKLKpUBRjX2r5pY2FGqK8Tob5O+uckSZ7luJhWGXRUBhyxlcl+naHuwS0hnrzy6zmSc0s4cCmL0YGuRFbOWvRwta2zi8QU3DXYm5U7IolIzOVscp5cvKyFLqTm8+i3J9DqJKYP7MqTEzr2f0/B9LUouEhKSmLLli0kJCRQXl5e67WVK1caZGCCaWvTWg4dUVkB7HgFjv+PLkCeZI2DorhO5cnF42jVNsvGCmTVV1irKRQKBT7O1vg4WzMx2B2o/u/YWeoeWJqruHNgV9Yfiuf7Y4mMDnTVV+bs7WlaSyJVuthaMKmPB7+fTuW7owm8dWffFp0nLa+Ue9cdo7BMw/DuzqyY0a9WPyhBaAvNDi527drF7bffTrdu3YiMjCQkJIS4uDgkSSI0NLQtxiiYoJrb1bQ6iUfH9eCzfbH6wKIj34iaLXYv/Po45MlVKyO03emviiVv+DM4tEHlybZWM0BcPD6g09Q9mDPUl/WH4tl+Po3swjKT3IZ6tfnD/Pj9dCq/nkzmxSm9sbVo3o/swjIN9647RmpeKT1cbfjs7sGozUxvlkbofJodXLzwwgssXbqU119/HTs7OzZt2oSbmxvz589n8uTJ1z6B0CkUl2vo6WZLkIcdH+6K5sNdcn2F6yqwKCuAHcvgeGXxOAdfvu/6LKmndxNtfwMzJ/+79vEGqjzZlq4OLKDz1D3o7WlPf28HIpLy2HwiWb8s0stEZy4Ahnd3prurDbGZRWw5ldKsVvcarY5/fXeC86n5dLFVs27RUBw6WJ0SoeNqdnBx4cIFNmzYIL/ZzIySkhJsbW15/fXXmTZtGo888ojBBymYhoLSCnZfzODPM2nsjcqgtKJuxcdxQW5GGJkRXDVbweD7qLjpFT5YdYwMzUw+mdjALJ4Jz1iAXNegvgCxs9Q9mDPUl4ikM3x7JJ6EHLmOiCnPXCgUCuYN9eWNPy7w7ZF45g71adKShiRJvLLlHHsjM7E0V/Lf/xuCj7N1O4xYEGTNDi5sbGwoKysDwMvLi5iYGPr06QNAVlaWYUcnGF1ecQU7LqTz55lU/o7OolxbHVD4OFvhbmfJ8fgrKJALRc/49CAbHhzGID9no425TZXmy7MV4Wvlx46+cPvH0H0Mu8+lkVFQRhdbNRN6uxt3nC3UWBJuR52xqLKqcgnPWq0iLlsOLJyszXGzszDpJOQZod68+1ck51LyOZ2UR38fx2u+54u/Y/n2SAIKBXw4ZyADmvAeQTCkZgcXw4cP559//iE4OJhbb72VpUuXcubMGTZv3szw4cPbYoxCO8suLGP7+XS2nknlUEw2mhq/rXZ3teGWEA9uCfFk14V0Vu2M5qmJgSwa5c/k1X+TnFvCnM8P89W9wxjRw8WIf4s2ELMbtiyGvET58ZD7YcJrcsls5BoCADMH+Yh1bROkUir4cFc0IV72nE2pbrP+0e5LJp2E7GSj5ta+nvx8Mplvj8RfM7j443Qqb229CMC/bw2utRVZENqLQrq6A9k1xMbGUlhYSL9+/SguLubpp5/mwIED9OzZk1WrVjWpPHh+fj4ODg7k5eVhb2+6653Xk/T8Uv46l8afZ9I4cjmbmrPfvTzsmBziwZS+ngS42aJQKOpdmy8u1zB59d8k5BSjUir4cuEQxgS6GulvZECl+bDjZQhfJz929INpH0O30fpDkq4Uc+O7e5Ak2Pv0WPy7mFbdBEFWMzkVYKCvIycTck0+V+hYXA53rTmElbmKIy+Nx96y/tyJ8PgrzP3iMOUaHQtH+vPK1GCxM0QwqKbev5s9c7F8+XLuvvtuJEnC2tqaTz75pFUDFYwnObeEP8+ksu1sGuEJV6gZZvbt6sDkEA9uCfGgu6ttnffWtzZvrTZj+5LR3PLh31zOKuKB9cf5z/xQ/fbGDunq2YqhD8L4V/SzFVV+OJaIJMGoni4isDBhi8cHIEkSq3bKCcgdIbAAGOznRKC7LVHphfxyMpkFI/zrHBOfXcQDX8nt0yf0duPl20RgIRhPs2cubr/9drZv346Liwtz5szhnnvuYcCAAc26qJi5aBtNKWx158Cu/Hk2jW1nU4morMBYJdTXkVtCPJkc4tGq5K9yjY4nNp7kz7NpmCkVfDhnILf282zx+YyiNB+2/xtOrJcfO/nLuRXdbqxzqEarY9Q7u0nPL+PjeQO5rZ9X+45VaLaAl7ZSoZUwVymIfnOKsYfTJOv+ucyrv50nyN2ObU/eWCtwuFJUzoxPDxKbVUTfrg58/9Bwg/YjEYQqbTZzsWXLFnJzc/nhhx/47rvvWL16NUFBQdx9993MmzcPf3//1oxbaIWGClu9uuUs6w7G08XWQr9lFOSK00P8nZkS4sGkEI9aDZ1aQ22m5KO5A1n6YwS/nkrh8Q0nKNP0Z3poByk3fGknbHkC8pPkx0MfhAmvgrr+GYk9kZmk55fhYqPm5mCxvm3qwnZFU6GVOlyBsDtDvVmx7SKR6QWcSLiiT5quap8em1VEV0cr/rdwsAgsBKNr0b9AR0dHHnzwQR588EGSkpLYsGEDX375JcuWLUOj0Rh6jEIT1axHkFVYhqOVOd8cSSCnSK6imlVYhkqpYER3F27p68HNwR642tVtjGUIZiolK2cNwNJMxffHE1n6YwSlFbpm7dNvM3veltuiX70ttDQP1t8Oqafkx07+MO0/4H9Do6erTuT0FomcJq4jFwhzsDJnaj8vfgxP4tvDCQzyc67VPt3Owoy1i4bgZmdp7KEKQut6i1RUVHD8+HGOHDlCXFwc7u4deG29k1g8PoDo9AK+OhSvf06pgDGBrtwS4snEYHecbNTtMhaVUsHb0/tiYa7kq0PxvPjzGco0WhaN6tYu12+QUlW3UualnfDjQrkwFsCwh2H8sgZnK6ok55awNzIDkFt7C6aroxcIW7UjCjOVvBTy+5lUlk0N5ou/Y/ktIgWlAiYGuxPobro1O4TrS4uCiz179vDdd9+xadMmtFot06dP57fffuOmm24y9PiEZirTaDmZmKt/rFIqOPHyRBysjFOZT6lU8NrtfbA0V/H5/lhe++08pRU6HhnbwyjjAWqX4taUQmEGnPxafs7SEeZ8B/6jmnSqH44lopNgRHeXehNfBdPR0QuEqZQKNhxNxNXWgszCMh755gSHYrMB0EmIRGLBpDQ7uPD29iY7O5tJkybx2WefMXXqVCwtxTScqfj2cAJJV0oAMFcpqNBKrD8YZ9TfyBQKBS/c0gtLcxVhu6J5Z9tFSiq0LJkQYJxsdq0GvAeDZz/4+4Pq572HwIJfrzlbUUWj1fHDcXkXyVxTWO4RGtXRC4RdPctSFVjAdVZ2X+gQmh1cLFu2jLvuugsnJ6drHyy0q/zSCt79Sy6eM6G3G//9vyEms6asUCh4amIgluZK3t0WSdiuaMoqtDx/S6/2CTB0Okg6Cmc3wbmfoSiz9utKM7h/Z7NOuS8qk9S8UpyszZnURywJCm1v8fgAyjU6Pt5zSf/ckgkBIrAQTE6zg4sHH3ywLcYhGMAD649TWqHDydqcNXcPAkxvTfnRsT2xNFPx+u/n+Wx/LKUVWl6Z2gelsg0CDEmCtNNyQHF2c3WtCgArZ3Dyg5SToFKDtlxui96M3h9ViZwzQr2xMFMZevSCUK+nJwWxZl8MGp28lfaJCaZZWVS4von9Sp1ERn4px+NzAFgxox9mqupdC6a2pnzvDd2wNFfx0i9nWH8onvCEK/z62A2orgowWtzvIStaDijO/ATZ1VtvUdtBr1uh70xIOg77VsC4l+SAYt+7zWqHnpZXyu6LciLnnKFiSURoP2G7otHoOt5WWuH6IoKLTmL1rmi0OrkQ1s31VMQ0tR8+84b5YmGm5OkfIzibnM+tYX/z++M36IOimpn9TZKbWDlDsUmerahiZgmBkyBkBgTcDOZWciBRM7CA2kmeNR834IfjciLn0G7O9HQTiZxC++jIW2mF64sILjqBmMxCvj8mT/m/MKV3hyn5O2OQN5bmKh7fcIKLaQXc8uHf/LH4Rtbsi6mzZbBehRlw7hc5oEg8XP280gx63CQHFEFTwPKqKnI6be3AokrVY5220XFrdZL+854nZi2EdtLRt9IK1xcRXHQC722LRKuTmNDbnSH+HavV+a39PFGbDebhr8OJzigk6OU/kaRGst9LcuHCb3JAcXkfSFUt4BVysauQ6dB7Gtg00pF13AsNv9aEJZH90Zkk55bgYGXO5BBRkVNoHx19K61wfRHBRQd3IuEK286loVTAs5ODjD2c5tvzNhOVKr5ctIj/+/IokiQX/Vo8PkBevtBpYdRiiPxTTsq8tENOvqzSdZA8Q9HnTrBvn54eG45UJ3JamotETqF9dPSttML1RQQXHZgkSazYKm89nTnIu2NW56uslqn2ywbkFuY6CX5d9RjT8r4Bt2A4GAYVxdXvcQuWA4qQ6eDcvV2Hm55fyq7KRM65Q0VFTkEQhPqI4KID230xg6NxOViYKZu/o6K1GurPAdUzDo0tP1QZ8yyHYrMZEb+GjYE6MhwH0O3ku/TNi5Nfzzgvf3fyh5CZclDhHmyov0Wz/Xg8Ea1OYoi/EwEdMZgTBEFoByK46KC0Ool3tsmzFotGdTNYR9Mmq68/B1Rv6Rz3UvVzkgQlV6AgDQrToCBd/z0q5hLKjERK1PYMT/gcEoDKlYY0yYkYt5sZNe0h6Boqt3E1Ip1OYsPRyoqcIpFTEAShQSK46KA2n0giKr0QBytzHhljhD4dNbdullyB7uMgfB1E/iHnQaRGwH8nVAYU6bXzJGoIBFACNZrpSgoly53fYV2yJ9YZ5uyy74O7CeyA+ftSFsm5JdhbmjGlr6exhyMIgmCyRHDRAZVWaPVbzx4b1wMH63ZuSlaQBpf/htx4sHSAw5/IX1WSw+t/n5UT2HqAnXvd7zG74eQ3oFKj0JbzbO9s9pUHEpNZxP3rj/P9Q8OxVhv3n2tVIud0kcgpCILQKBFcdEDrD8aRmleKl4MlC0b4t/0Fi3Mg7gBc3i9/ZUU2cKACBs6vDBg8wNa9+rutO5g30OBu37tyYFGjWqblnjfZNOwZbjo+jDPJeTy58RSf3j2oThXP9pKRX8rOC+mAWBIRBEG4lg4fXKzaEYVKqah3K1aLy0ebsLziCv5T2bToqZuD2uY36LJCSDgk15G4vB9STwM199ArwLM/dBstF7I6vbG6P4ejX7P6c9TK0biqWqbjnjf5beASxh0bxvbz6az48wIv3WqcZM4fw5PQ6CQG+TkR5CESOQVBEBrT4YMLlVJRb3W6ZpeP7iA+2XeJ/FINQe523Dmwq2FOqimDxKPVMxPJx0GnqX2May85mOg2GvxGgbWzHBgcDGtxfw7gmtUyu+q0vDezH09sPMUXf1/Gv4sN84f5tfIv3Dw6ncTGY/KSyJwhYvupIAjCtXT44KJm+VuNVsfoQFcOxmQ3rXx0B5OSW8Laf+IAeO6WoLpLBE3dHqrVQOqp6pmJhMOgKa19vKNfZTAxBrrdKC9vXH2+BmYcmhVgNKFa5jQgPruYlTuiWPbrOXycrBkd6HrtcxvIwZhsEnNKsLM047Z+7VOoSxAEoSPr8MEFyAFGfmkFYbsvEba7csmgkwUWIC8BlWt0DO3mzLggt7oHNLQ9dO87sPct6DkBvpsD8f9AWX7t99q6V89MdBst15VoTCv7czTX4zf1JC67iM0nknns2xP89MjIdlueqGqtfufArlipRSKnIAjCtXSK4ALgpSm9+d/fl5GoUT66E4lMK2DTiSQAXrilV/3NyWrOHBRng2sQHPkcMi/Iz1/aWX2spQP43yjPTHQfA10Cm1dHopX9OZpLoVDw9vS+JF0p4ejlHO5dd4xfHhuFq52Fwa9VU2ZBGX+dSwNgzhCRyCkIgtAUnSa4+Gj3JX3KoU6Cl385y/I7Qow6JkN676+L6CS4JcSDgb5O1S+UF0PGBbnNePpZSDsjJ1ceWVP7BObW4DeyeqnDo68809GBWJip+OzuQUz/9CCXs4q4/6vjbHxgeJvOJmw6ISdyDvBxJNjL/tpvEARBEDpHcFEzeTMyrYA/zqTy9eF4utiqeWJCx0/oPHo5h50X0vFU5rIsSAN/74W0ykAiJ6ZGZ9B6KFSwaCt4hYKZur2G3GacbNR8uXAId37yDxGJuSz98RQfzw1F2QZbVHU6iY2VSyKitbogCELTdfjgomZgsXh8AAnZxew4n065VseqndEoFPVvUzVp2grIioK0M0hpZ7A4foBwixhcFAXwRz3H27jKMxHuIeDRD5KOwtHPq7eHXt4PvsPb/a/RVrp1seGzuwdx9/+OsPVMGu+5RPLc5F4Gv87h2GzisouxtTDjtv6iIqcgCEJTdfjgQquTaiVv+rpYs3CUP5/vj8XZRk2FtpHf6g2tJc28inMqlzPOVn4/DZmR+nLZCqB/5R8khQpFl4DKIKIveISAe1+5wmXN6xz9vHXbQzuAYd1deGdGP576IYJP98bQzcWGWQbeJvpd5azFHQO9jF4dVBAEoSPp8D8x6yuQ9di4nvx4PJGconLc7RuoCtmYlnb8vFYzr2GPwLlfqnMj0s5CflL9Y7CwR3Lvwy+pzhwq9qLfoFHcPXUymDfSoMxQ20M7iOmh3sRlFRG2+xIv/nyGrk5WjOrZxSDnzi6sTuQUFTkFQRCap8MHF/VxsDLnyQmBvLLlHKt2RDFtgBd2ls3ov9Gcjp81jXlWriGx503ITZA7eZ74GlJOVCZZfip/Xc3Rr3ImomppIwQc/dhwNJEXo87gZG3Oy1PGgfk1/g7tvD3UFCyZGEhcdjFbIlJ4+Jtwfn50JD3dWr9FddOJJCq0Ev29Hejj5WCAkQqCIFw/OmVwATBvmC/rD8URm1nEJ3tjmrcmX99v+7vfgP3vwcB7wKUnHP4UClJrtA+v/CrNld9z8mv5q4q2HMwswa13dW6ERwi495G3hV6luFzD6p1y5dHHbwpoWnDUzttDTYFCoeDdmf1IyS3hePwVFq07xi+PjsLFtuVbVCVJtFYXBEFoDYUkSdK1DzOs/Px8HBwcyMvLw96+7bb37Tyfzv1fHUdtpmTXU2PwcbZu2huLcyDpGPzzoVxwqrnMLKsrXipUMP1zOaBw6QmqpsVz/9lziff+isTH2YqdT43BwqxjbRttb9mFZdz5yUEScooZ5OfEt/cPa3HflUMx2cz94jA2ahVHX5qAjUWnjcEFQRCapan37079U3N8bzdGdHfhUGw27/0VSdjcgXUP0ukg86K8wyLxGCQegezo+k9oZiWXwa76svWo//GRz+SKmFW7NXJioe/MJo87p6icNXtjAHj65iARWDSBi60FXy4cwvRP/iE8/grP/HSaD2cPaNEW1aqKnLcP6CoCC0EQhBbo+D85G0m+VOx/jw89ihh2eShbIlJYNMqfgW5KSDouz0wkHoGkcCjLq3tel55y4am006A0B10F3LAExj7X+Hj2vSsHFq3YrfHx7ksUlGkI9rRnquhl0WQ93WxZc/cgFnx5lN8iUvB3sWbpzUHNOseVonK2nZUTOUVtC0EQhJbp+MHFNZIv3YY9zNvdzqBLOIzzVy8iaeJRcNVKkLk1dB0EPkPBeyh4D4Hj/6u986IqSFAoGg4SDLBbIzGnmK8PxwHw/C292qQ4VGc2smcX3prel2d/Os1Huy/h72LDjEHeTX7/phNJlGt1hHS1p6+3SOQUBEFoiY4fXNS8eWvK5D4Z+9+XO36aWcKRNcwB+W9a1UXc0Q98hsnBhM9QcOtTOxeipUGCAXZrrNwRRYVW4oaeXdq182dnMmuwD3FZciLv85tP09XJiuHdXa75PjmRU14SEYmcgiAILdfxgwuQb96aMvj7ffmriqYUVBbQNZTj2p58cbkLaQ59+eFfdzSex9DSIKGVuzXOpeTxy6lkgDapOHk9efrmIOKzi/njTCoPfS1vUe3uatvoe47FXSEmswhrtYrb+4vlKEEQhJbqHMEFwPiX4e8PAAkUSrj5TXl2wqMvmKkJLtdw8r29ZFwpY/3BOB4c3aPhcxlpS+c72yKRJJja30tMybeSUqngg1n9Sc4t4VRiLveuO8bmR0fhbNNwfxV9Imf/ZtZFEQRBEGpRGnsABrPvXUCSd2hIOigvBO9B+mZd1moznp4kJ/d9tPsSOUXlRhxsXf9cymJ/VCbmKgVP39zxm62ZAktzFV8sGIy3kxVx2cU8/HU4ZZr6Z51yi8v540wqIJZEBEEQWqtzBBc1cyRezpS/73mzMuCoNiPUm2BPewpKNXxYWaDKFOh0Eiv+vAjA/GF++LnYGHlEnYernbxF1c7CjKNxOTy/6Qz1lXbZfCKZco2OYE97+olZI0EQhFbp+MFFQ8mX9QQYKqWCf9/aG4BvjiRwKaPQGCOuY+vZVM4k52GjVvGvm3oaezidTqC7HZ/cHYpKqeDnk8mE7bpU6/VaiZzDfFEoxA4dQRCE1uj4wUVjyZfjXqqTfDmyZxfG93JDq5NY8eeFdhxo/co1Ot77KxKAB0f3oEsrylYLDbsxwJXl00IAWLUzil8rE2cBwuOvEJ1RiJW5imkDRCKnIAhCa3X8hM4WJF++MKU3e6My2Xkhg4OXshhpoE6aLbHxWALx2cV0sVVz/43djDaO68G8Yb7EZRfx+f5Ynvo+gq6OVgz2d9a3Vp/a35N1/8Sh1Un1dtsVBEEQmqbjz1y0QE83W+YPk5P23vjjAlpdu7dXAaCwTEPYLrnU+BPjA0Sp6Xbw/ORe9HC1QStJ3PO/o5xOyuWP03Iip0qpYOWOKFSicJkgCEKrXJfBBcg3cztLM86n5rP5RJJRxvDfv2PJKizH38WaOWKHQrtQKhX89vgNuNlZUFKh5c5PDlKm0dHFVs2Go4k8NTGQxeMDjD1MQRCEDu26DS5cbC341zg5efK9vyIpLtdc4x2GlVlQxuf7YwF4ZlIvzFXX7X+KdmetNuP3x2/AzsJMP2uVVVguAgtBEAQDua7vaP830h8fZysyatzo28tHu6MpLtfS39uBKX092vXaArjZW/LDwyP0j81VChFYCIIgGMh1HVxYmqv0ZbY/2xdLen5pu1w3LquI747ISYTP3dJLbH00kh3n0wE5sKjQSvr8F0EQBKF1ruvgAuDWvp6E+jpSUqHl/cotoW3t/e2RaHQSY4NcGdnDeDtVrmdhu6JZuSOKpyYGEv3mFJ6aGMjKHVEiwBAEQTCA6z64UCgU/Pu2YAB+OpHEuZS8Nr1eRGIuv59ORaGAZyeJ5mTGUDOwqFoKWTw+QAQYgiAIBnLdBxcAob5OTO3vhSTBm39cqLc8tCFIUnWZ7zsHdCXYy75NriM0TquT6k3erAowjLU1WRAEobMQhRUqPTspiL/OpXEwJpvdFzMY39vd4NfYH53Fodhs1CqlKNJkRI199iKpUxAEofXEzEUlH2dr7h0lV8h8c+sFKrQ6g56/ZnOyBSP88HG2Nuj5BUEQBMFUiOCihkfH9cDZRk1sZpG+kZWh/BqRzIXUfOwszHhsnGhOJgiCIHReIriowd7SXD9lvmpHFHklFQY5b5lGy/t/yS3eHx7bAycbtUHOKwiCIAimSAQXV5k7xIeebrZcKa7gkz2Xrv2GJvjmcALJuSW421vol14EQRAEobMSwcVVzFRKXprSG4C1/8SRmFPcqvPll1bw8W55a+OSCYFYqVWtHqMgCIIgmDIRXNTjVOIVfJ2tKdfqWLHtYq3XwnZFs2pHVJPP9dm+GK4UV9DD1YaZg7wNPVRBEARBMDkiuKiHSqkkoXLG4o/TqYTH5wDVxZea2pI7Pb+U/x24DMCzk3thJpqTCYIgCNcBUeeiHlW1DlZWzlAs//0C44JcWbUzutHOmasqA4+q11fvjKa0QscgPycupuZzPiVf1LcQBEEQOj0RXDRg8fgAiso0fLY/llOJuZxKzMXHyYrkKyX8Z88lvJ2s8HW2xtfZGmcbNQqFApVSoQ9IpvT15IfjiQD0dLPVByaCIAiC0NkppLaqdd2I/Px8HBwcyMvLw97etEtg93hx6zXLQduoVfhUBhrZhWWEJ+Ti52xNfE4x3bvYEJtV1OiMhyAIgiB0BE29f4uZi0aE7YpGq5P0Lbkn9/Ggt6c9CTnFJOYUk5BTTFp+KUXlWi6mFXAxrUD/3vjKnA0RWAiCIAjXGxFcNODqzplVj4O97PlgVn/9caUVWpKulJB4pTLgyJaDjh3n05EAtUopAgtBEAThuiKCi3o01JIbqpM8qx5bmqvo6WZLTzfbWu/ffj4dtUpJuVZH2K5oEWAIgiAI1w0RXNSjsZbcVa83pKEZj5rvFwRBEITOTAQX9WhpS+7mzHgIgiAIQmclggsDas2MhyAIgiB0FmIrqiAIgiAITWLSW1Gr4pn8/HxjXF4QBEEQhBaoum9fa17CKMFFQYFcD8LHx8cYlxcEQRAEoRUKCgpwcHBo8HWjLIvodDpSUlKws7NDoWhaEzBBEARBEIxLkiQKCgrw8vJCqWy4GadRggtBEARBEDov0QNcEARBEASDEsGFIAiCIAgGJYILQRAEQRAMSgQXgiAIgiAYlAguBEFokr1796JQKMjNzTX2UARBMHFit4ggCPUaO3YsAwYMYPXq1QCUl5eTk5ODu7u72EIuCEKjRG8RQRCaRK1W4+HhYexhCILQAYhlEUEQ6li4cCH79u3jww8/RKFQoFAoWLduXa1lkXXr1uHo6Mjvv/9OUFAQ1tbWzJw5k6KiItavX4+/vz9OTk48/vjjaLVa/bnLy8t59tln6dq1KzY2NgwbNoy9e/ca5y8qCEKbEDMXgiDU8eGHHxIVFUVISAivv/46AOfOnatzXHFxMWFhYWzcuJGCggKmT5/O9OnTcXR0ZOvWrcTGxjJjxgxuuOEGZs+eDcCiRYuIi4tj48aNeHl58fPPPzN58mTOnDlDQEBAnWsIgtDxiOBCEIQ6HBwcUKvVWFtb65dCLl68WOe4iooKPv30U3r06AHAzJkz+frrr0lPT8fW1pbg4GDGjRvHnj17mD17NjExMWzYsIGkpCS8vLwAePrpp9m2bRtr167lrbfear+/pCAIbUYEF4IgtJi1tbU+sABwd3fH398fW1vbWs9lZGQAcOLECSRJIjAwsNZ5ysrKcHFxaZ9BC4LQ5kRwIQhCi5mbm9d6rFAo6n1Op9MBctNClUpFeHg4KpWq1nE1AxJBEDo2EVwIglAvtVpdKxHTEAYOHIhWqyUjI4Mbb7zRoOcWBMF0iN0igiDUy9/fnyNHjhAXF0dWVpZ+9qE1AgMDmT9/PgsWLGDz5s1cvnyZY8eO8c4777B161YDjFoQBFMgggtBEOr19NNPo1KpCA4OxtXVlYSEBIOcd+3atSxYsIClS5cSFBTE7bffzpEjR/Dx8THI+QVBMD5RoVMQBEEQBIMSMxeCIAiCIBiUCC4EQRAEQTAoEVwIgiAIgmBQIrgQBEEQBMGgRHAhCIIgCIJBieBCEARBEASDEsGFIAiCIAgGJYILQRAEQRAMSgQXgiAIgiAYlAguBEEQBEEwKBFcCIIgCIJgUP8P5tjmSJIjySIAAAAASUVORK5CYII=",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "sample_size = 20\n",
        "x_sample = x[0:sample_size]\n",
        "y_sample = y[0:sample_size]\n",
        "time_series_filtered_x_sample = time_series_filtered_pd.x.tolist()[0:sample_size]\n",
        "time_series_filtered_y_sample = time_series_filtered_pd.y.tolist()[0:sample_size]\n",
        "\n",
        "# Plot the data points\n",
        "plt.subplot(2, 1, 1)\n",
        "set_params_plot()\n",
        "plt.plot(x_sample, y_sample, \"x-\", label=\"Data sample\")\n",
        "plt.plot(\n",
        "    time_series_filtered_x_sample,\n",
        "    time_series_filtered_y_sample,\n",
        "    \"x-\",\n",
        "    label=\"Smoothed signal\",\n",
        ")\n",
        "plt.legend()\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "25",
      "metadata": {},
      "source": [
        "Until now, the data was considered static and ingested all at once in a single batch: let's switch to streaming data by adding timestamp to the data!\n",
        "\n",
        "You will create two batches of points: one with all the \"on-time\" data points arriving at time 0, and another one with \"late\" data points arriving at a later time.\n",
        "To make the computation interesting, the late data points should be in the middle of the signal:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "26",
      "metadata": {},
      "outputs": [],
      "source": [
        "init_late = 6\n",
        "length_late = 7\n",
        "\n",
        "# Extracting the late points\n",
        "x_sample_late = x_sample[init_late : init_late + length_late]\n",
        "y_sample_late = y_sample[init_late : init_late + length_late]\n",
        "\n",
        "# Removing the late points from the original sample\n",
        "x_sample_ontime = x_sample.copy().tolist()\n",
        "del x_sample_ontime[init_late : init_late + length_late]\n",
        "y_sample_ontime = y_sample.copy().tolist()\n",
        "del y_sample_ontime[init_late : init_late + length_late]\n",
        "\n",
        "# The on-time data points have a timestamp of 0, the other ones have a timestamp of 1\n",
        "time = [0 for i in range(len(x_sample_ontime))]\n",
        "for i in range(len(x_sample_late)):\n",
        "    time.append(1)\n",
        "\n",
        "out_of_order_x_sample = x_sample_ontime + x_sample_late.tolist()\n",
        "out_of_order_y_sample = y_sample_ontime + y_sample_late.tolist()\n",
        "\n",
        "out_of_order_time_series_pd = pd.DataFrame(\n",
        "    {\"x\": out_of_order_x_sample, \"y\": out_of_order_y_sample, \"time\": time}\n",
        ")\n",
        "out_of_order_time_series_pd.to_csv(\"./ooo_ts.csv\", index=False)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "27",
      "metadata": {},
      "source": [
        "Let's plot the resulting data sample: the late points, in red, have been removed from the original time series:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "28",
      "metadata": {
        "lines_to_end_of_cell_marker": 2
      },
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhcAAADPCAYAAABGK/MjAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAPI1JREFUeJzt3XlYlOX6B/DvO8MM+y6CyKqAiqKomVupqORWmppHj5pLpzJbNLPUjsclrE62iNIvMyvFrNQ6aZk7oqi55QaorMqqgIDs62zP7w+YkYEBWWZ4Z4b7c11c8O734Mhzz7NyjDEGQgghhBAtEfAdACGEEEKMCyUXhBBCCNEqSi4IIYQQolWUXBBCCCFEqyi5IIQQQohWUXJBCCGEEK2i5IIQQgghWmXCx0MVCgWysrJgbW0NjuP4CIEQQgghLcQYQ2lpKVxdXSEQNF4/wUtykZWVBXd3dz4eTQghhJA2yszMhJubW6PHeUkurK2tAdQEZ2Njw0cIhBBCCGmhkpISuLu7q8rxxvCSXCibQmxsbCi5IIQQQgzM47o0UIdOQgghhGgVJReEEEKIngmNSEJYZLLGY2GRyQiNSGrniFqGkgtCCCFEzwgFHDZpSDDCIpOxKSIJQoF+j7Tkpc9Fc8jlckilUr7DIESnxGJxk8O5CCEd05IxvgCATbU1FEvG+KoSi3eC/VTH9ZXeJReMMeTk5KCoqIjvUAjROYFAAG9vb4jFYr5DIYTomRlPuOFqWgE2RSQhNCIJDDCIxALQw+RCmVh07twZFhYWNMkWMVrKyeSys7Ph4eFB73VCCIoqJDh6Kwd/RN/H5dQCMFaznwEwEXAGkVgAepZcyOVyVWLh6OjIdziE6JyTkxOysrIgk8kgEon4DocQwoNKiRyRCQ/w+40snEnKhVTOVMe62pnhflEVAECmYAiLTDaIBEOvkgtlHwsLCwueIyGkfSibQ+RyOSUXhHQgMrkCf93Jx8HoLBy/nYNyiVx1rKeLNaYEdsXDsmp891cqRvk5ISopD906War1wdBnepVcKFH1MOko6L1OSMfBGMP1jCIcjL6PQ7HZeFguUR3rameOKYGumBLYFT1crBEWmYzv/krFO8F+GO7jiKikPJRUybBsrK9BJBh6mVwQQgghxiLpQSn+iL6PP6KzcK+wUrXfwVKMZ/t2wZRAVwzwsFf7sCFXMFXnzUqJHEIBh/yyavxjkDs4joNcwTQ9Sm9QcmHgRo0ahcDAQGzevJnvULB+/Xr8/vvviI6O5juUVklLS4O3tzdu3LiBwMBAvsMhhBiw+0WV+DMmC7/fuI+EnFLVfguxEON6u2BKoCuG+3SCSKh5KPqyYD/Vz+ZiIXw7WyEhpxQxmcV6XWOhRMmFFmVmZmL9+vU4evQo8vPz0aVLFzz//PNYu3ZtmzuoRkVFISgoCIWFhbCzs1Pt379/v0G31XMchwMHDuD555/nOxS4u7sjOzsbnTp1avY1hp5QEUK0p6BcgiM3s3EwOgt/pxWo9ouEHEb6dcaUQFeM7eUMc7Gwxffu52aHhJxSxN4rwvg+LtoMWyeMLrkIrZ25TFNmFxaZDLmCqWWE2pKSkoKhQ4fCz88Pe/bsgbe3N27fvo333nsPR48exaVLl+Dg4KD15+rinh2VUCiEi4v+/6clhLSP5pQni0Z2Q0TcAxyMzsKZpDzI6jRXDPZ2wJTArpjQxwX2lm2by6avuy32Xc1E7L3iNt2nvRjd1IB8TZn6xhtvQCwW48SJExg5ciQ8PDwwYcIEnDx5Evfv38fq1atV53p5eeHjjz/GSy+9BGtra3h4eGD79u2N3jstLQ1BQUEAAHv7mna5BQsWAKhpFnn77bfV7v3hhx9i3rx5sLKygqenJ/744w/k5eVhypQpsLKyQkBAAK5evar2jAsXLmDEiBEwNzeHu7s7lixZgvLy8iZf8yeffAJnZ2dYW1vjX//6F6qqqtSOX7lyBcHBwejUqRNsbW0xcuRIXL9+XS1WAJg6dSo4jlNt3717F1OmTIGzszOsrKwwaNAgnDx5sslY1q9fj8DAQHzzzTdwd3eHhYUFZsyYoTYZm0KhQEhICNzc3GBqaorAwEAcO3ZM7ffMcZyqFiIqKgocxyEyMhJPPPEELCwsMGzYMCQmJgIAwsPD8cEHHyAmJgYcx4HjOISHh6vi8fDwgKmpKVxdXbFkyZIm4yd6bP16YMMGzcc2bKg5ToxSY+VJaEQSNkUk4fjtHAzccBJL90YjMiEXMgVDb1cb/HtiT1xYNRr7Fg3F7MEebU4sgJqaCwCIvVcExvS7vwUAgPGguLiYAWDFxcVq+ysrK1lcXByrrKxU7VMoFKy8Wtqir8+PJzDPlYfY58cTNG4390uhUDTr9Tx8+JBxHMc+/vhjjcdfeeUVZm9vr7qfp6cnc3BwYF999RVLTk5m//3vf5lAIGDx8fEar5fJZOy3335jAFhiYiLLzs5mRUVFjDHGRo4cyZYuXao6V3nvbdu2saSkJLZ48WJmbW3Nxo8fz3755ReWmJjInn/+edarVy9VPLGxsczKyoqFhoaypKQkdv78eda/f3+2YMGCRl/zvn37mFgsZt9++y1LSEhgq1evZtbW1qxfv36qcyIjI9nu3btZXFwci4uLY//617+Ys7MzKykpYYwxlpubywCwnTt3suzsbJabm8sYYyw6Oppt27aNxcbGsqSkJLZ69WpmZmbG0tPTG41n3bp1zNLSko0ePZrduHGDnTlzhvn4+LDZs2erztm0aROzsbFhe/bsYQkJCWzFihVMJBKxpKQkxhhjqampDAC7ceMGY4yx06dPMwBs8ODBLCoqit2+fZs9/fTTbNiwYYwxxioqKtjy5ctZ7969WXZ2NsvOzmYVFRXs119/ZTY2NuzIkSMsPT2dXb58mW3fvl1j3Jre80TPhIQwBtR8b85+YlS2nExinisPsc0Riezv1IfsuS/PMc+Vh9S+nt54in1+PIElPyjRWRwSmZz5rj7CPFceYil5ZTp7zuM0Vn7Xp/fNIpVSOfzXHm/VtV+euoMvT91pdPtx4kLGwUL8+F9RcnIyGGPo1auXxuO9evVCYWEh8vLy0LlzZwDAxIkT8frrrwMAVq5cidDQUERFRaFnz54NrhcKharmj86dO6v1udBk4sSJWLRoEQBg7dq1+PrrrzFo0CDMmDFD9byhQ4fiwYMHcHFxwWeffYbZs2erakB8fX0RFhaGkSNH4uuvv4aZmVmDZ2zevBkvvfQSXn75ZQDAhx9+iJMnT6rVXowePVrtmm+++Qb29vY4c+YMnn32WTg5OQEA7Ozs1Joj+vXrh379+qm2P/zwQxw4cAAHDx7Em2++2ejrrqqqwq5du+Dm5gYA+PLLLzFp0iR88cUXcHFxweeff46VK1di1qxZAICNGzfi9OnT2Lx5M7766qtG7/vRRx9h5MiRAIBVq1Zh0qRJqKqqgrm5OaysrGBiYqIWf0ZGBlxcXDB27FiIRCJ4eHjgySefbPT+RM+tWVPzfe3aR9sbNtRsh4Q8Ok6M0pIxvlAwhtCTyQg9+agGo5OVGM/2dcWUQFcEutvpfFi5SCiAfxcbRGcWIfZeEbw7Wer0eW1ldM0i+ojVVmHVffP17dtX9TPHcXBxcUFubi4AYMKECbCysoKVlRV69+7d4ufVvbezszMAICAgoME+5fOuXbuG8PBw1TOtrKwwbtw4KBQKpKamanxGfHw8hg4dqrav/nZubi5ee+01+Pn5wdbWFra2tigrK0NGRkaT8ZeXl2PFihXw9/eHnZ0drKyskJCQ8NjrPDw8VImFMh6FQoHExESUlJQgKysLw4cPV7tm+PDhiI+Pb/K+dX+fXbp0Ub22xsyYMQOVlZXo1q0bXnnlFRw4cAAymazJZxA9t2ZNTSKxdi1gakqJRQdTJVWofhZwwA8vPYlL74/B+sm90b/eEFJd6utmCwAG0e9C72suzEVCxIWMa/F1X0fdxZen7kAk5CCVM7w12geLR3Vv8bObw8fHBxzHIS4uTuOoh4SEBNjb26uNQqg/woPjOCgUNW/g7777DpWVlRrPa4661yjf9Jr2KZ+nUCiwaNEijf0CPDw8Wvx8pQULFiAvLw+bN2+Gp6cnTE1NMXToUEgkkiave++993D8+HF8/vnn8PHxgbm5OV544YXHXlef8nXW/Y9f/48AY+yxfxia+t1p4u7ujsTERERERODkyZN4/fXX8dlnn+HMmTMGPbKnw1uzBvjwQ0AiAcRiSiw6iMOx2dh25i6Amj4YcgVDdGYRRvg5tXssfd3sAKQj9l5Ruz+7pfQ+ueA4rllNE3WFRSbjy1N3VBOQKDtzioQCnYwPdnR0RHBwMLZu3Yply5bB3NxcdSwnJwc//fQT5s2b1+zstmvXrg321Z0mWtsGDBiA27dvw8fHp9nX9OrVC5cuXcK8efNU+y5duqR2zrlz57B161ZMnDgRQM1Q3fz8fLVzRCJRg9d07tw5LFiwAFOnTgUAlJWVIS0t7bExZWRkICsrC66urgCAixcvQiAQwM/PDzY2NnB1dcVff/2FESNGqK65cOFCm5osxGKxxn8Tc3NzTJ48GZMnT8Ybb7yBnj174ubNmxgwYECrn0V4tmHDo8RCIqnZpgTDqCXmlOLtfTcAAE942uN/i4epyhOg/WfI7Fdbc3HrfglkcgVMGpkjQx/ob2StpGm9+yVjfPFOsJ/GXr/a8n//93+orq7GuHHjcPbsWWRmZuLYsWMIDg5G165d8dFHH7Xp/p6enuA4DocOHUJeXh7Kysq0FHlNH4yLFy/ijTfeQHR0NJKTk3Hw4EG89dZbjV6zdOlS7NixAzt27EBSUhLWrVuH27dvq53j4+OD3bt3Iz4+HpcvX8acOXPUEi+gZsRIZGQkcnJyUFhYqLpu//79iI6ORkxMDGbPnt1kTYGSmZkZ5s+fj5iYGJw7dw5LlizBP/7xD1V/iPfeew8bN27Evn37kJiYiFWrViE6OhpLly5t6a9MLf7U1FRER0cjPz8f1dXVCA8Px/fff49bt24hJSUFu3fvhrm5OTw9PVv9HKNkSKMw6vaxqK5+1ETSWPzE4BVXSjHzm4uQyhk8HMyx99UhANqnPGlMNycrWIqFqJTKcSdPe2WALhhdclF3ytS6lG8IXU2Z6uvri6tXr6J79+6YOXMmunfvjldffRVBQUG4ePFim+ej6Nq1Kz744AOsWrUKzs7OTXZsbKm+ffvizJkzSE5OxtNPP43+/ftjzZo1qv4FmsycORNr167FypUrMXDgQKSnp2Px4sVq5+zYsQOFhYXo378/XnzxRSxZskTVoVXpiy++QEREBNzd3dG/f38AQGhoKOzt7TFs2DA899xzGDduXLM+8fv4+GDatGmYOHEinnnmGfTp0wdbt25VHV+yZAmWL1+O5cuXIyAgAMeOHcPBgwfh69v6Tx/Tp0/H+PHjERQUBCcnJ+zZswd2dnb49ttvMXz4cPTt2xeRkZH4888/aaXf+oRCzQW0siAXtnyiIZ3Q1Hmzbh8MSjCMjkLB8PbeGyiqlMLazAS/v/GUWi2BrsuTxggFHPp0re13kanf/S44xtp/wGxJSQlsbW1RXFwMGxsb1f6qqiqkpqbC29tb4wgFQhpjqDNldvj3fP2CWx9HYaxfX5PoaIpnwwZALtevWhbSZptOJCLs1B2Ymgjw2+JhqgJdH3x8JB7bz6Zg7hAPfPh8wOMv0LLGyu/69L7PBSHEiNUd5qnsLKlPiQXQdOKgT3ESrThxOwdhtVMW/HdagF4lFgAQ0NUwRowYXbMIIcTArFnzqJMkjcIgPLqTW4Z3fokBACwY5oVpA9wec0X7U87UGZ9dgmqZ9jv4awslF8QorF+/3uCaREgtTaMwCGlnpVVSLNp9FWXVMjzp7YDVkzRPisg3dwdz2FuIIJUzJGSXPv4CnlByQQjhD43CIHpAoWBY/ksM7uaVw8XGDF/NHtDoUuh84zgOAXXWGdFX1OeCEMKPxkZhAOpTbROiY1uj7uBE3AOIhQJse3EgnKxN+Q6pSf3cbHE2KQ8x94rxIt/BNIKSC0IIP+RyzZ03lds6mDCOkPpOJ+bii9pJsTY83xuB7nb8BtQMfWtrLm7qcadOSi4IIfygURiEZ2n55Vi65wYYA2YP9sDMQa1f7qA9KdcYSc4tRYVE1uJZrNuDfjYqEUIIITpUXi3Dot3XUFIlwwAPO6x7zp/vkJrN2cYMzjamULCaqcD1ESUXhBBCOhTGGFb8FovEB6VwsjbF13MHwtRET2aEbaa+et6pk5KLDoLjOPz+++98h9FqCxYs0LjiLCGEtNT2syk4HJsNEwGHr+cMgLON4c2Oq1zELEZP+11QcqElbS38wsPDYWdnp7V42mr9+vUIDAzkOwyVLVu2IDw8vEXXGHpCRQjRvr+S87HxWAIAYN1z/njCq23rPvFF32su9K8XSFvROgBGydZWv6bgJYQYnsyCCry55zoUDJgx0A1zhxjuSsXKTp3pDytQXCGFrYWI54jUGV/NhZ6utLhp0yYEBATA0tIS7u7ueP3111XLpkdFRWHhwoUoLi4Gx3HgOA7raxMgiUSCFStWoGvXrrC0tMTgwYMRFRXV5LOSk5MxYsQImJmZwd/fHxEREQ3OWblyJfz8/GBhYYFu3bphzZo1kEqlAGpqUT744APExMSo4lHWGjT1OhrDcRy+/vprTJgwAebm5vD29savv/6qds7NmzcxevRomJubw9HREa+++qrafevXDI0aNQpLlizBihUr4ODgABcXF9XvDKhZCh0Apk6dCo7jVNsxMTEICgqCtbU1bGxsMHDgQFy9erXJ+Akhhq9SIsei3ddQVCFFXzdbbHi+DziO4zusVrOzEMPDwQIAEHu/iN9gNDC+5ELTUsh6sNKiQCBAWFgYbt26hV27duHUqVNYsWIFAGDYsGHYvHkzbGxskJ2djezsbLz77rsAgIULF+L8+fPYu3cvYmNjMWPGDIwfPx7Jyckan6NQKDBt2jQIhUJcunQJ27Ztw8qVKxucZ21tjfDwcMTFxWHLli349ttvERoaCqBmOfXly5ejd+/eqnhmzpz52NfRlDVr1mD69OmIiYnB3Llz8c9//hPx8fEAgIqKCowfPx729va4cuUKfv31V5w8efKxy8rv2rULlpaWuHz5Mj799FOEhISoEqkrV64AAHbu3Ins7GzV9pw5c+Dm5oYrV67g2rVrWLVqFUQi/cr4CTEmoRFJCIvU/PcqLDIZobVzTOgSYwz/PnATcdklcLQUY9vcgTATGVYHTk2UtRd6uYgZ40FxcTEDwIqLi9X2V1ZWsri4OFZZWdn2h4SEMAYwJhbXfA8Jafs9mzB//nw2ZcqUZp//yy+/MEdHR9X2zp07ma2trdo5d+7cYRzHsfv376vtHzNmDHv//fc13vf48eNMKBSyzMxM1b6jR48yAOzAgQONxvPpp5+ygQMHqrbXrVvH+vXr1+LXoQkA9tprr6ntGzx4MFu8eDFjjLHt27cze3t7VlZWpjp++PBhJhAIWE5ODmOs4e935MiR7KmnnlK756BBg9jKlSvVnlv/NVtbW7Pw8PDHvq72otX3PCF6aMvJJOa58hDbcjKpWft1YcdfKcxz5SHW7f3D7MKdfJ0/r71sP3OXea48xF7ZdaXdntlY+V2f8fW5UFqz5tESznqw0uLp06fx8ccfIy4uDiUlJZDJZKiqqkJ5eTksLS01XnP9+nUwxuDn56e2v7q6Go6OjhqviY+Ph4eHB9zcHq3mN3To0Abn/e9//8PmzZtx584dlJWVQSaTwcbGRievQ1MMQ4cOVS00Fh8fj379+qldP3z4cCgUCiQmJsLZ2VnjPfv27au23aVLF+Tm5jYZ/zvvvIOXX34Zu3fvxtixYzFjxgx07969yWsIIa23ZIwvAGBTRBLuF1Xi2b5dcCOjCJsikvBOsJ/quK5cSnmIDw/X1JL+e2IvDO2u+W+nIdLnmgvjaxZR0qOVFtPT0zFx4kT06dMHv/32G65du4avvvoKAFT9HDRRKBQQCoW4du0aoqOjVV/x8fHYsmWLxmsYYw321W9XvHTpEmbNmoUJEybg0KFDuHHjBlavXg2JRKKT19EYZVyMsUbbPptqE63fnMFxHBQKRZPPXL9+PW7fvo1Jkybh1KlT8Pf3x4EDB1oYOSGkJZaM8cWcwR7YdyUTL37/NzZFJGHZWF+dJxZZRZV446frkCsYng90xUvDvXT6vPbWp6stBByQU1KF3JIqvsNRY5zJhZ6ttHj16lXIZDJ88cUXGDJkCPz8/JCVlaV2jlgshrzeWgr9+/eHXC5Hbm4ufHx81L5cXFw0Psvf3x8ZGRlq97948aLaOefPn4enpydWr16NJ554Ar6+vkhPT39sPM15HY25dOlSg+2ePXuqYo6OjkZ5eblajAKBoEGtTUuIRKIGrwEA/Pz8sGzZMpw4cQLTpk3Dzp07W/0MQsjjyeQKRGcWqe2rkMg1fhjSliqpHIt/vIaH5RL4d7HBf6f1NegOnJpYmprAp7MVAP2rvTC+5KKxlRbbIcEoLi5Wq2GIjo5GRkYGunfvDplMhi+//BIpKSnYvXs3tm3bpnatl5cXysrKEBkZifz8fFRUVMDPzw9z5szBvHnzsH//fqSmpuLKlSvYuHEjjhw5ojGGsWPHokePHpg3bx5iYmJw7tw5rF69Wu0cHx8fZGRkYO/evbh79y7CwsIafHr38vJCamoqoqOjkZ+fj+rq6ma9jsb8+uuv2LFjB5KSkrBu3Tr8/fffqg6bc+bMgZmZGebPn49bt27h9OnTeOutt/Diiy822iTSHF5eXoiMjEROTg4KCwtRWVmJN998E1FRUUhPT8f58+dx5coV9OrVq9XPIIQ83rfnUnE7q2aaamFtAf/N2RT85/dbUCi0n2AwxrD2j1uIuVcMOwsRvnlxIMzFht+BU5OArnYA9HC+C913/2hIpx06161rvPNmSEjNcR2YP38+A9Dga/78+YwxxjZt2sS6dOnCzM3N2bhx49gPP/zAALDCwkLVPV577TXm6OjIALB1tXFKJBK2du1a5uXlxUQiEXNxcWFTp05lsbGxjcaSmJjInnrqKSYWi5mfnx87duxYg86N7733HnN0dGRWVlZs5syZLDQ0VK1DaVVVFZs+fTqzs7NjANjOnTub/TrqA8C++uorFhwczExNTZmnpyfbs2eP2jmxsbEsKCiImZmZMQcHB/bKK6+w0tJStd9v/Q6dS5cuVbvHlClTVL9vxhg7ePAg8/HxYSYmJszT05NVV1ezWbNmMXd3dyYWi5mrqyt78803ee1MSR06ibFLyStj3d4/rNbx8OXwv5nnykPMc+UhtmzvDSaVybX6zN0X05jnykPMe9UhdjYpV6v31je7LqQyz5WH2LzvL7fL85rboZNjTIf1Uo0oKSmBra0tiouL1ToRVlVVITU1Fd7e3jAzM7zpWIlmHMfhwIEDNH23BvSeJ8ZMoWAY8elp3CuqhKeDBaLeG6Vqmnj9x2s4cisHADC+twu2/DNQK+t7XEsvwKztlyCVM6ya0BOvjTTuDtvRmUV4/qvzsLcQ4fqaYJ03/TRWftdnfM0ihBBC9MLeK5m4V1QJEwGHH18erFbwbZ07EJP7uULAAcdu5+DVH66hUtKwj1RLPCipwms/XodUzjApoAsWjejW1peg93p1sYZIyKGwQop7hZV8h6NCyQUhhBCtyymuwn+P1AwBXTWhJ9xrZ5OsK+yf/bHrpSdhLhLiTFIeFuz8G2XVslY9TyJT4PWfriOvtBp+zlb49AXj68CpiamJED1damoQYvSo3wUlF0TnGGPUJEJIB8IYw5o/bqG0WoZ+7nZYONy70XOf9nXCD/96EtamJricWoA5311GUUXTw+I1CTl0G9fSC2FtZoLtLz4BS1PjncapPuV8Fzf1aMQIJReEEEK06uitHETEPYCJgMPG6QEQCpquQRjk5YCfXxkCewsRYjKLMGv7JeSVVjf7eb9cycSPlzLAccCWWYHw6tT4hH7GqK9q+fUifgOpg5ILQgghWlNUIcHaP24DAF4f1V1VZf84AW622LdoKJysTZGQU4qZ31xEVtHj+xBEZxbhP7/fAgAsG+uH0T1bP3zdUCmXX791v0QnQ3tbQy+Ti8fNskiIseBhsBYhOvXR4Xjkl1XDp7MV3hjt06Jr/Zyt8euioehqZ46U/HLM2HYR6Q/LGz0/v6wai3+8BolcgWB/Z7wZ1LLnGQvfzlYwEwlQVi1DSn7Tq1S3F71qlBKLxRAIBMjKyoKTkxPEYnGH6JBDOibGGPLy8sBxHK3MSozCX8n5+PXaPXAcsHF6QKuGlnp1ssQvrw3F3O8uI7U2wfjp5cHwdbZWO08qV+CNn64ju7gK3Zwssekf/SB4TPOLsTIRCtDH1RZX0wsRk1kMn87Wj79I1zHxHUBdAoEA3t7eyM7Obva00oQYMo7j4ObmBqHQOGcPJB1HhUSG9w/EAgBeHOKJgZ4Orb5XVztz7Fs0BC9+9zcSH5TiuS//wvSBbvhoaoDqnI+PxONyagHEQgGGd+8Ea7OOnaD3dbPD1fRCxN4rwvSBbo+/QMf0KrkAamovPDw8IJPJNK4LQYgxEYlElFgQo7DpRBIyCyrhamuGFeN7tvl+na3NsG/REMzf8Tdi7hXjp8sZkCsYPpneFwdu3MPO82kAAIlcASdr0zY/z9D1c69dIfW+fowY0bvkAoCqmpiqigkhRP/FZBZhx/lUAMBHUwNgpaVhoHYWYvz48mD8a9dV/J1agL1XMpFTUoWLdx+qzmmPZdsNQUDXmuQiLqsEUrkCIiG/XSr1skMnIYQQwyCRKbDyt1goGDAl0BVBPTtr9f7WZiLsWvgkRvg5AQCiEvNQLavp9P92Oyzbbii8HC1hbWaCapkCiTmlfIdDyQUhhJDW2372LhJySmFvIcLaZ/118gxzsRDfzhuIcb0fDTMVCTm8PdZPJ88zRAIBp5rvQh+WX6fkghBCSKvcyS1DWOQdAMC653rD0Up3fR9MTYToVTtnhkjIQSpnCItM1tnzDJFyvgt9WH5dL/tcEEII0W8KBcP7+2MhkSswqocTpgS66vR5YZHJ2ByZrOpjERaZjE0RSQBATSO1+qlm6uS/5oKSC0IIIS320+V0XEkrhKVYiI+mBuh0TiJlIlG386byOyUYjyhrLpIelKJKKoeZiL+RaJRcEEIIaZGsokp8cjQBALBifE90tTPX6fPkCqZxVIhyW64nU17zrYutGTpZiZFfJsHtrBIM9LTnLRZKLgghhDQbYwz/+f0WyiVyDPCww9whnjp/5rLgxjtuUo1FjdCIJAgFHPq62eFUQi5i7xWpkouwyGTIFazJ36O2UYdOQgghzXYwJgunEnIhFgqwcXrfx654StqHUMBhU0QSKiUyAI9GjCiblNr734lqLgghhDRLQbkEH/wZBwB4I8inwXofhD/1+6DE3CvS2FelvVDNBSGEkGbZcCgOBeUS9HC2xuJR3fkOh9SzZIwvXhvZDQCQklfOW2IBUHJBCCGkGaISc3Hgxn1wHPDJ9ACITaj40EerJvSCcuCOSMjx1ieF3h2EEEKaVF4tw+oDtwAAC4d5o78Hf6MQSNPCIpPBGCAWCnidaKzVycWdO3dw/PhxVFZWAqjpQUwIIcT4fHY8EfeLKuFmb453x9GU2/qqbh+LpI8m4J1gP2yKSOIlwWhxh86HDx9i5syZOHXqFDiOQ3JyMrp164aXX34ZdnZ2+OKLL3QRJyGEEB5cSy/ErotpAICPpwbAQkzjAPSRvk001uKai2XLlsHExAQZGRmwsLBQ7Z85cyaOHTum1eAIIYTwp1omx6rfYsEYMH2Am2plUqJ/mppo7J1gv3afaKzFKeiJEydw/PhxuLm5qe339fVFenq61gIjhBDCr62n7yI5twyOlmL8Z1IvvsMhTdC3icZaXHNRXl6uVmOhlJ+fD1NT3a2IRwghpP0kPSjF1qiaFU/XT+4Ne0sxzxERQ9Li5GLEiBH44YcfVNscx0GhUOCzzz5DUFCQVoMjhBDS/uQKhhX/i4VUzjC2V2c827cL3yERA9PiZpHPPvsMo0aNwtWrVyGRSLBixQrcvn0bBQUFOH/+vC5iJIQQ0o52XUhDdGYRrExNsOH5Pjpd8ZQYpxbXXPj7+yM2NhZPPvkkgoODUV5ejmnTpuHGjRvo3p1mbCOEEEOWWVCBz08kAgBWTeiJLra6XfGUGKdWjSlycXHBBx98oO1YCCGE8IgxhtW/30KFRI4nvR0w+0kPvkMiBqrFycXZs2ebPD5ixIhWB0MIIaT9KJfpVo4mOHDjPs4m5UFsIkDvLjbYEpncrst0E+PR4uRi1KhRDfbVbY+Ty+VtCogQQkj7UC7TDQCzB3sg5FDNiqeDvOyx80Ia3qHEgrRSi5OLwsJCtW2pVIobN25gzZo1+Oijj7QWGCGEEN2qO4Pj4ZvZKKqQwsnKFOfvPORtNU1iHFqcXNja2jbYFxwcDFNTUyxbtgzXrl3TSmCEEEJ0b8kYXyTmlOLwzWwAQF5ZNSUWpM20tiqqk5MTEhMTtXU7QgzX+vXAhg2aj23YUHNcH+9NOqRr6QWIiH+g2hYLBZRYkDZrcXIRGxur9hUTE4Njx45h8eLF6Nevny5iJMSwCIXA2rUNk4ANG2r2C4X6eW/S4aTll+PlXVchkSkA1CQWErmCt2W6ifFocbNIYGAgOI5rsMT6kCFDsGPHDq0FRojBWrOm5vvatY+2lYV/SMij4/p2b9KhFJZLsDD8CgorpACAt0b7YPkzPVSrawL8rElBjEOLk4vU1FS1bYFAACcnJ5iZmWktKEIMXt0k4MMPAYlEe4W/Lu9NOoQqqRyv7r6K1PxyAMCiEd2w/JkeAPhdppsYD47Vr4JoByUlJbC1tUVxcTFsbGza+/GEtB9T05rCXywGqqv1/97r19c0rWhKVDZsAORy6tdh4BQKhqX7ovFnTBbEQg7/fNIDH0zp0+C8sMhkyBWM5rkgappbfjer5iIsLKzZD16yZEmzzyXEqG3Y8Kjwl0hqtrVVu6Creyv7dADq96vb9EIM2ucnEvFnTBZMBBzCFz6JYT6dNJ5HNRakLZqVXISGhjbrZhzHUXJBCNCwH4RyG2h7EqDLe1OfDqO25+8MbI26CwD4ZHrfRhMLQtqM8aC4uJgBYMXFxXw8nhDdCglhDKj53pz9+nJvTfcTi7V7X8KbM4m5rNv7h5nnykNs04lEvsMhBqq55XerFi4jpP6aBHV1+LZauVzzp3zldlumyNflvevfT9lZVCymGgsDF59dgtd/ug65gmFa/654eyw1eRDdalVyce/ePRw8eBAZGRmQSCRqxzZt2qSVwIh+q7smQd0EQzmMrUOvSdBUh8e2FtK6vHdduuwvQtpVTnEVXgq/grJqGYZ0c8An0/uqrQdFiC60OLmIjIzE5MmT4e3tjcTERPTp0wdpaWlgjGHAgAG6iJHoobrD1eQKhteDuuObMymqxII6gxkwXfbpIO2qrFqGl8KvILu4Ct2dLPHN3CcgNtHaxMyENKrFycX777+P5cuXIyQkBNbW1vjtt9/QuXNnzJkzB+PHj9dFjEQPVUhk8OlshR4u1tgSmYwttTP6UWJh4DR13tTUyZPoPZlcgTd/vo647BJ0shIjfOGTsLUQ8R0W6SBanFzEx8djz549NRebmKCyshJWVlYICQnBlClTsHjxYq0HSfRDaZUUpxJycfRmDqKSclElVTQ4J6hHZx4iI1rTXn06iE4xxrDu4G1EJebBTCTAd/MHwd3Bgu+wSAfS4uTC0tIS1bUT9ri6uuLu3bvo3bs3ACA/P1+70RHeFVdIERH/AEdvZuNccj4k8kcJhbuDOZytzXA1vRAcAAZg+tcXsOfVwRjo6cBbzKQN2qtPBx860ARh355LwU+XM8BxwJZZ/RHobsd3SKSDaXFyMWTIEJw/fx7+/v6YNGkSli9fjps3b2L//v0YMmSILmIk7exhWTVOxD3AkZvZuHj3IWSKR5O4dnOyxIQ+LpjQpwsi4x8g9GQy3gn2w8LhXhi/+RzuF1Vi1vZL+OGlwRja3ZHHV0FIPR1kgrDDsdn4+EgCAOA/k/wxrrcLzxGRjqjFycWmTZtQVlYGAFi/fj3Kysqwb98++Pj4NHuyLaJ/HpRU4fjtHBy9mYPLqQ9RJ59ATxdrjO/jgokBXeDb2QocxyEsMlmVWCj7WES8MwLjN59DRkEF5n5/GTsWDMJIPyeeXhEh9XSACcKupRdg2S/RAIAFw7zw0nAvXuMhHVeL1xZZuHAh5s6di9GjR7d6OBOtLaIf7hdV4ujNbBy7lYNrGYWo+04I6GqL8X1cMKGPC7o5WTW4trF5LqqkckzYcg6p+eUQCwX4as4ABPs76/qlENJ8yoRCOczWSBKL9IflmLr1AgrKJRjbqzO+efEJCAU05JRoV3PL7xYnF5MnT8aJEyfg6OiIWbNm4cUXX0RgYKBOgiMt05yJrab274qjt3Jw7FY2Yu4Vq50zwMMOE/p0wfg+Lm3q/CWRKbB07w0cvZUDEwGHLbP6Y1LfLq2+HyFap8sF5XhQWC7B9K8vICW/HAFdbbFv0RBYiGmORKJ9Wl24rK6DBw+iqKgIv/zyC37++Wds3rwZPXr0wNy5czF79mx4eXm1JW7SBo1NbLX+4C2EX0hHJytT1ZBRAOA4YJCXAyb2ccG4Pi7oYmuulTjEJgJ8+c/+WP5rDP6IzsJbe66jWtYP0wa4aeX+hLSJkU0Qplw+PSW/HF3tzPH9gicosSC8a/OS6/fu3cOePXuwY8cOJCcnQyaTPfYaqrnQHeUMmfOGesLOXIQfL2egoPzRLKpCAYeh3RwxIcAFz/i7wMnaVGexyBUM/95/E/uuZoLjgI+eD8DswR46ex4hj9XYBGEG2jRSd/l0a1MT/Pb6MPg5W/MdFjFiOqu5qEsqleLq1au4fPky0tLS4OxMbet8WzLGF8kPSvHDxXTVPgEHjPRzwoQ+XRDs7wx7S3G7xCIUcPjvtACYigT44WI6/n3gJqplciwc7t0uzydEjYFPEKap2fOLiJrl0wUcEOzvTIkF0RutSi5Onz6Nn3/+Gb/99hvkcjmmTZuGP//8E6NHj9Z2fKSFqmVy3MgsUm0LBRyurwmGrTk/M/MJBBw+mNwbZiIhtp9NwQd/xqFKqsDiUd15iYd0YAY+QVj9Zs99VzLw1ema5dMVDPDqZMlneISoaXGziJubGx4+fIhx48Zhzpw5eO6552BmZtaih1KziO7s+CsVIYfiAAAiIQepnOnFlNyMMYSeTEZYbZ+PJWN8sWysLy2gRDosmVwBiVwBqYyhWi6HRKao+ZIrHv0sU6C6zvbh2Gwcu52D4T6OuJRSAHntmHF9+D9OOgadNYusXbsWM2bMgL29fZsCJNpXUiXFp8drJs8Z26szvps/SNUHAwCvf3w4jsM7wX4wEwnw6bFEhEUmo1oqx6oJPSnBIDonV7A6hXVNQS6VszoFuhzVdQp0tQK+9udqDcek8oYJQNPXy1Xbijb0djt/56Hq52VjfSmxIHqnxcnFq6++qos4iBa8susqqqQK2FuIsG3uQADqq5fW3ebL66N8YGYiRMihOHxzNgVVUjnWPdcbAhqPbzQUCgaJXHNhrLatVgA/+uRe3dQ1tQW5tJECXOP1coXqE76+4jhALBRAbCKAqYlA9bPySyQUqB0/lZALBaupnVw61o/v8AlpgMYrGYnckipcTS8AAHwyvS9MhI+WVVYmFPryB/alp7xhJhJi9e83setiOq5lFOKPN55qMOGPcm6OZcH0x7MxyoK8scJYWcBLNRToDT9tq1fNa/okL5U3XoArf5bpyfusKWITAUzrFeBqBbqwiX21X6YNjgnVtk3rJgYm6slB/fuZCLhm1+CFRSbjZHwuxEIBJHIFwiKTef/QQEh9lFwYic2RyZAraibCekbDjJj69sdn9mAPmJoI8O6vMbh1vwSTws7h0FtPqZIiZXPOO3qUWDDGmv9puXZb2kgh3Xh1u1zDeUytOl39/gZQkDdWQNf5ucGndaEAonqFdP3CvWFhLax3jFPfp7yvsPkFub6p+/9iyRhfvWn2JKQ+Si6MwN28Muy7kgkAeH9iL4P5wzl9oBtMRQIs2XMDCTmlmLDlHA4veRrbztzFpogkLB3ji5ee8kZBuaTZbeMNPqnXL8QfU90uqdMuLpU1TCb0nUjINVIICxv5tK2+bVr3k3YzEgD1Y48KcpGQU51jKO9HfVc/sQD0r9mTECVKLozAZ8cSIVcwjO3ljEFehrXU+bN9XSEWCrD4x+tIzi2D33+Oqo5tiUxWm1FU39QvyOtWf5s2KNxrC/gmqsaV1zcnAWisJoAKcuMlV2ge+aVvzZ6EAFqYobM1aCiq9lzPKMS0rRcg4IBjb48w2El0ziTlYf6Ovxs9biLgWtU23vDTtno1ubIg1/RpvcnqeKGAOqESQjqcdpmhk/CLMYZPjtQMPX1hoJvBJhYAEFM78Zdybo5FI7rh9SAfVTU9re5ICCGGQ/D4U4i+OpWQi7/TCmBqIjDoERV125KTP5qId4L98M3ZFOy6kAYzkZASC0IIMTBUc2Gg5AqGjcdqai0WDvfW2oqm7Y06qRFCiPGh5MJA7b9+D0kPymBrLsLikYa7Tgd1UiOEEONDyYUBqpLKVZ/q3wjqDlsLfhYl04ammnOoxoIQQgwT9bkwQLsupCG7uAqutmaYN9SL73AIIYQQNQafXIRGJKlW2qwvLDIZobWf8I1FcYUUX52+AwB455keMBMJeY6IEEIIUWfwyYVQwGGThgRD2VHQ2EYabD1zByVVMvRwtsbU/l35DocQQghpwOD7XNQdWSCTKzDCzwkX7j5sMALBGGQVVWLn+TQAwMoJPYwucSKEEGIcDD65AGoSjJIqKcJO3UHYqdomAyNLLICaJiCJTIEnvR0Q1KMz3+EQQgghGhl8s4jS6om9oPwcL+CMb6RBYk4pfrt+DwDw/oSetIYEIYQQvWU0ycWXp+5AOSOCggFrfr/Fazza9tnxBCgYMKGPC/p72PMdDiGEENIoo0gu6s7yOCmgCwBg96V0bDlpHCNF/k4twMn4XAgFHN4d14PvcAghhJAmGXyfi/rTR2c8rEBE3ANI5AqEnkwGx3EG3UTCGMN/j8YDAGYOckd3JyueIyKEEEKaZvA1F/Wnj/ZwtMCC4V4AAAdLMaRyBY/Rtd3x2w9wI6MI5iIh3jbgJIkQQkjHYfA1F5qmj34jyAe/Xs1EQbkEzjZmPESlHTK5Ap8er1mc7OWnvdHZgF8LIYSQjsPgay40sTUX4e2xNUlHaEQSSqukPEfUOr9cvYeUvHLYW4jw6ohufIdDCCGENItRJhcAMHuwB7o5WeJhuQRbo+7yHU6LVUhk2FzbIfWt0b6wNjPcxckIIYR0LEabXIiEAvx7Qi8AwPd/pSKzoILniFpm5/k05JZWw93BHHOGePAdDiGEENJsRptcAMCYXp0xtJsjJDIFPjueyHc4zVZQLsG22tqWd5/pAVMTWpyMEEKI4TDq5ILjOKye1AscBxyMycKNjEK+Q2qW/zt1B6XVMvh3scFzfV35DocQQghpEaNOLgCgT1dbTB/gBgD48HA8GGOPuYJfmQUV2H0pDQCwakJPCGhxMkIIIQbG6JMLoKZpwVwkxLX0Qhy5mcN3OE3aFJEEqZzhKZ9OGOHnxHc4hBBCSIt1iOTCxdZMNZTzk2PxqJbJeY5Is9tZxfg9+j4AYOX4njxHQwghhLROh0guAGDRyG7obG2KzIJK7LqQxnc4Gm08lgjGgOf6uSLAzZbvcAghhJBW6TDJhYXYRLXo15en7qCgXMJzROrO38nH2aQ8iIQc3n2m4ayjhBBCiKHoMMkFAEwf4Ab/LjYorZLp1YqpCgXDJ0drpvmeM9gTno6WPEdECCGEtF6HSi6EAg7/mVQzsdaPlzNwJ7eM54hqHLmVjZv3i2EpFuLN0T58h0MIIYS0SYdKLgBgmE8njOnZGXIFwye1S5nzqe4EX6+O6I5OVqY8R0QIIYS0TYdLLgDg/Ym9IBRwOBmfiwt38nmNZe+VDKQ/rEAnKzFeftqb11g6jPXrgQ0bNB/bsKHmOCGEkFbrkMmFT2crzBlcs17Hh4fjIVfwM7FWWbUMYZHJAIClY3xhaWrCSxwdjlAIrF3bMMHYsKFmv5CmWyeEkLbokMkFUFOYW5uZIC67BPuv3+Mlhu/OpSC/TAIvRwvMepIWJ2s3a9YAISHqCYYysQgJqTlOCCGk1TpscuFoZYo3g2o6T352PBEVElm7Pj+vtBrbz6YAAN4b1xMiYYf9p+BH3QTD1JQSC0II0aIOXaLNH+YFdwdz5NYp6NvLl6eSUSGRo5+bLSYGuLTrs0mtNWsAsRiQSGq+U2JBCCFa0aGTCzORUDXN9jdnUvCgpKpdnpuWX46fL2cAAFZO6AmOo8XJeLFhw6PEQiJpvJMnIYSQFunQyQUATAroggEedqiUyvF57ZBQXfv8RCJkCoZRPZwwrHundnkmqaduH4vq6oZ9MAghhLRah08uOI7Df571BwD87/o93M4q1unzYjKLcCg2GxwHrBhHi5PxQlPnTU2dPAkhhLRKh08uAGCAhz2e6+cKxoCPDseDMd0MTWXs0TTfUwO7wt/VRifPIY8hl2vuvKlMMOT6uWouIYQYCppYodaKcT1w/HYOLtx9iFMJuRjTy1nrzzibnI+LKQ8hFgqwLJgWJ+NNU5NkUadOQghpM6q5qOXuYIGXhtfMkPnRkXhI5Qqt3r/u4mTzhnrC3cFCq/cnhBBC9AUlF3W8HtQdDpZipOSVY8/fGVq99x8x9xGfXQJrUxO8EUSLkxFCCDFelFzUYWMmUjVXhEYkobhSqpX7Vsvk+Px4zRLvr43qDntLsVbuSwghhOgjSi7q+ecgd/h0tkJhhRRbT9/Ryj1/vJSB+0WVcLYxVTW9EEIIIcaKkot6TIQCrJ7YCwCw83waMgsq2nS/kiop/u9UzeJky8b6wVxMi2IRQggxbpRcaBCdWQgPBwtI5Ap8cixB7VhYZDJCI5Kafa9vztxFYYUU3Z0s8cJAN22HSgghhOgdSi40EAoEyKitsTgcm41r6QUAahKLTRFJEAqaN133g5IqfP9XKgBgxfieMKHFyQghhHQANM+FBkvG+AIANtXWUGw4FI+gHk4IPZmMd4L9VMfrC61NPJTHN59MRpVUgYGe9kjILkFcVgnNb0EIIcToUXLRiCVjfFFeLcM3Z1MQnVmE6MwiuNub435hJb46fQdu9ubwcLCAh4MFHCzF4DgOQgGnSkgmBnTBL1czAQA+na1UiQkhhBBi7Dimq7mum1BSUgJbW1sUFxfDxka/p8Du/u8jkCua/hVZioVwr000HpZV41pGETwdLJBeUIFunSyRkl/eZI0HIYQQYgiaW35TzUUTwiKTIVcwiIQcpHKG8b1d0KuLDTIKKpBZUIGMggrklFShXCJHQk4pEnJKVdem1/bZoMSCEEJIR0PJRSOUnTeViYFy29/VBl/8o5/qvCqpHPcKK5FZWJtwPKxJOiLiHoABEAsFlFgQQgjpUCi50KB+YgE07OSp3DYTCeHT2Qo+na3Urj8R9wBioQASuQJhkcmUYBBCCOkwKLnQQK5gGpsylNtN9cForMaj7vWEEEKIMaPkQoOmhos2lSC0pMaDEEIIMVaUXGhRW2o8CCGEEGNBQ1EJIYQQ0ix6PRRVmc+UlJTw8XhCCCGEtIKy3H5cvQQvyUVpac18EO7u7nw8nhBCCCFtUFpaCltb20aP89IsolAokJWVBWtra3Bc8xYBI4QQQgi/GGMoLS2Fq6srBILGF+PkJbkghBBCiPGiNcAJIYQQolWUXBBCCCFEqyi5IIQQQohWUXJBCCGEEK2i5IIQ0ixRUVHgOA5FRUV8h0II0XM0WoQQotGoUaMQGBiIzZs3AwAkEgkKCgrg7OxMQ8gJIU2itUUIIc0iFovh4uLCdxiEEANAzSKEkAYWLFiAM2fOYMuWLeA4DhzHITw8XK1ZJDw8HHZ2djh06BB69OgBCwsLvPDCCygvL8euXbvg5eUFe3t7vPXWW5DL5ap7SyQSrFixAl27doWlpSUGDx6MqKgofl4oIUQnqOaCENLAli1bkJSUhD59+iAkJAQAcPv27QbnVVRUICwsDHv37kVpaSmmTZuGadOmwc7ODkeOHEFKSgqmT5+Op556CjNnzgQALFy4EGlpadi7dy9cXV1x4MABjB8/Hjdv3oSvr2+DZxBCDA8lF4SQBmxtbSEWi2FhYaFqCklISGhwnlQqxddff43u3bsDAF544QXs3r0bDx48gJWVFfz9/REUFITTp09j5syZuHv3Lvbs2YN79+7B1dUVAPDuu+/i2LFj2LlzJz7++OP2e5GEEJ2h5IIQ0moWFhaqxAIAnJ2d4eXlBSsrK7V9ubm5AIDr16+DMQY/Pz+1+1RXV8PR0bF9giaE6BwlF4SQVhOJRGrbHMdp3KdQKADULFooFApx7do1CIVCtfPqJiSEEMNGyQUhRCOxWKzWEVMb+vfvD7lcjtzcXDz99NNavTchRH/QaBFCiEZeXl64fPky0tLSkJ+fr6p9aAs/Pz/MmTMH8+bNw/79+5GamoorV65g48aNOHLkiBaiJoToA0ouCCEavfvuuxAKhfD394eTkxMyMjK0ct+dO3di3rx5WL58OXr06IHJkyfj8uXLcHd318r9CSH8oxk6CSGEEKJVVHNBCCGEEK2i5IIQQgghWkXJBSGEEEK0ipILQgghhGgVJReEEEII0SpKLgghhBCiVZRcEEIIIUSrKLkghBBCiFZRckEIIYQQraLkghBCCCFaRckFIYQQQrTq/wEvjXSKO40aEwAAAABJRU5ErkJggg==",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.subplot(2, 1, 1)\n",
        "set_params_plot()\n",
        "plt.plot(x_sample_ontime, y_sample_ontime, \"x-\", label=\"On-time data points\")\n",
        "plt.plot(x_sample_late, y_sample_late, \"x\", color=\"red\", label=\"Late data points\")\n",
        "plt.legend()\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "29",
      "metadata": {
        "lines_to_next_cell": 2
      },
      "source": [
        "Now, you will apply the filter to this data source.\n",
        "You first need to create a pipeline to apply the Gaussian filter, as done in the previous sections:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "30",
      "metadata": {
        "lines_to_next_cell": 2
      },
      "outputs": [],
      "source": [
        "def smooth_table(table):\n",
        "    points_within_50 = table.windowby(\n",
        "        table.x,\n",
        "        window=pw.temporal.intervals_over(\n",
        "            at=table.x, lower_bound=-50.0, upper_bound=50.0, is_outer=False\n",
        "        ),\n",
        "    ).reduce(\n",
        "        pw.this._pw_window_location,\n",
        "        xs=pw.reducers.ndarray(pw.this.x),\n",
        "        ys=pw.reducers.ndarray(pw.this.y),\n",
        "    )\n",
        "    # Applying the Gaussian filter\n",
        "    time_series_filtered = points_within_50.select(\n",
        "        x=pw.this._pw_window_location,\n",
        "        y=gaussian_filter(pw.this.xs, pw.this.ys, pw.this._pw_window_location),\n",
        "    )\n",
        "    return time_series_filtered"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "31",
      "metadata": {
        "lines_to_next_cell": 2
      },
      "source": [
        "Then, you need to read the input source.\n",
        "You are not working with a static data source anymore, but a streaming one.\n",
        "You can use `pw.demo.replay_csv_with_time` to replay a data source in a CSV file respecting the time between updates based on a timestamp columns (more information about this function in our dedicated [article](/developers/user-guide/connect/artificial-streams#replaying-static-csv-files-with-replay_csv-and-replay_csv_with_time)). Here the time is contained in the column `time`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "32",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "Output()"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "text/html": [
              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
            ],
            "text/plain": []
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# For streaming data, you need to define the schema\n",
        "class InputSchema(pw.Schema):\n",
        "    x: float\n",
        "    y: float\n",
        "    time: int\n",
        "\n",
        "\n",
        "ooo_input_table = pw.demo.replay_csv_with_time(\n",
        "    path=\"ooo_ts.csv\",\n",
        "    schema=InputSchema,\n",
        "    time_column=\"time\",\n",
        "    unit=\"s\",\n",
        "    autocommit_ms=100,\n",
        ")\n",
        "ooo_smoothed_table = smooth_table(ooo_input_table)\n",
        "pw.io.csv.write(ooo_smoothed_table, \"ooo_results.csv\")\n",
        "pw.run()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "33",
      "metadata": {},
      "source": [
        "Let's take a look at the results:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "34",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>x</th>\n",
              "      <th>y</th>\n",
              "      <th>time</th>\n",
              "      <th>diff</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>5</th>\n",
              "      <td>2.663173</td>\n",
              "      <td>9.995850</td>\n",
              "      <td>1722589159134</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>23</th>\n",
              "      <td>11.440568</td>\n",
              "      <td>11.651747</td>\n",
              "      <td>1722589160450</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>21</th>\n",
              "      <td>11.440568</td>\n",
              "      <td>10.975576</td>\n",
              "      <td>1722589160450</td>\n",
              "      <td>-1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>11.440568</td>\n",
              "      <td>10.975576</td>\n",
              "      <td>1722589159134</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>18</th>\n",
              "      <td>16.929219</td>\n",
              "      <td>11.780476</td>\n",
              "      <td>1722589160450</td>\n",
              "      <td>-1</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "            x          y           time  diff\n",
              "5    2.663173   9.995850  1722589159134     1\n",
              "23  11.440568  11.651747  1722589160450     1\n",
              "21  11.440568  10.975576  1722589160450    -1\n",
              "4   11.440568  10.975576  1722589159134     1\n",
              "18  16.929219  11.780476  1722589160450    -1"
            ]
          },
          "execution_count": null,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "results = pd.read_csv(\"./ooo_results.csv\")\n",
        "results = results.sort_values(by=[\"x\"])\n",
        "results.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "35",
      "metadata": {},
      "source": [
        "There are two new columns: `time` and `diff`.\n",
        "The column `time` corresponds to the processing time at which Pathway generated the output, and `diff` represents whether the output was added or removed.\n",
        "An update is decomposed in two simultaneous atomic operations: the removal of the last value (`diff==-1`) and the addition of the new one (`diff==1`).\n",
        "\n",
        "Here we have only two batches, so there are only two different values in the column `time`.\n",
        "\n",
        "Let's see the results of the first batch when the \"on-time\" data points were added to the system:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "36",
      "metadata": {},
      "outputs": [],
      "source": [
        "# The first batch has only additions, no need to filter on `diff` (all values are equal to 1).\n",
        "first_results = results[results[\"time\"] == min(results[\"time\"])]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "37",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.subplot(2, 1, 1)\n",
        "plt.plot(x_sample_ontime, y_sample_ontime, \"x-\", label=\"On-time data points\")\n",
        "plt.plot(first_results.x, first_results.y, \"x-\", label=\"Smoothed time series\")\n",
        "plt.legend()\n",
        "set_params_plot()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "38",
      "metadata": {},
      "source": [
        "As you can see, there is a gap in the middle of the time series as some points are missing.\n",
        "However, the Gaussian filter did its job by smoothing the signal with the data points it had at its disposal.\n",
        "\n",
        "Now, let's see what was the output when the second batch of points was ingested:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "39",
      "metadata": {},
      "outputs": [],
      "source": [
        "late_results = results[results[\"time\"] == max(results[\"time\"])]\n",
        "# We only focus on the new values, i.e., with diff==1\n",
        "late_results = late_results[late_results[\"diff\"] == 1]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "40",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.subplot(2, 1, 1)\n",
        "plt.plot(x_sample, y_sample, \"x-\", label=\"Total data points\")\n",
        "plt.plot(\n",
        "    late_results.x, late_results.y, \"x-\", color=\"red\", label=\"Updates of the smoothing\"\n",
        ")\n",
        "plt.legend()\n",
        "set_params_plot()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "41",
      "metadata": {},
      "source": [
        "You can see that the gap has disappeared, replaced by the late data points and the associated smoothed signal.\n",
        "\n",
        "Let's compare both outputs:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "42",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.subplot(2, 1, 1)\n",
        "plt.plot(x_sample, y_sample, label=\"Total data points\")\n",
        "plt.plot(\n",
        "    first_results.x, first_results.y, \"x-\", color=\"#ff7f0e\", label=\"Original smoothing\"\n",
        ")\n",
        "plt.plot(late_results.x, late_results.y, \"x-\", color=\"red\", label=\"Updated smoothing\")\n",
        "plt.legend()\n",
        "set_params_plot()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "43",
      "metadata": {},
      "source": [
        "The arrival of late data points has triggered an update of the output: not only the gap has been filled, but existing values have been updated to take into account the incoming data points.\n",
        "Furthermore, the smoothing has been updated only for data points close to the late points: Pathway did not apply the filter to the whole signal from scratch, but only updated the local parts that were impacted by the arrival of the late points.\n",
        "\n",
        "This is the power of Pathway: you can build your pipeline as if the data were static, and Pathway will take care of the late and out-of-order data for you.\n",
        "**Your results will always be up-to-date compared to the latest available data points.**"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "44",
      "metadata": {},
      "source": [
        "## Gaussian Filtering in Python: Conclusion\n",
        "\n",
        "Signal processing is a fundamental tool for extracting meaningful insights from data, but signal processing on real-world data requires data alignment.\n",
        "Pathway provides all you need to tackle the challenges of real-world digital signal processing on data streams.\n",
        "Now that you understand the differences between idealized signal processing and data stream processing, I'm sure you can leverage Pathway's capabilities to process, filter, and analyze data efficiently, even when dealing with imperfect sampling rates and data imperfections.\n",
        "\n",
        "If you want to learn more about DSP in Pathway, try our [tutorial](/developers/templates/etl/upsampling) about manipulating different data sources by *upsampling* a data source to match the sampling rate of given data source."
      ]
    }
  ],
  "metadata": {
    "jupytext": {
      "cell_metadata_filter": "-all",
      "main_language": "python",
      "notebook_metadata_filter": "-all"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.11.14"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}